Stabilize custom_code_classes_in_docs feature

compiler/rustc_feature/src/accepted.rs

@@ -138,6 +138,8 @@ declare_features! (
  (accepted, copy_closures, "1.26.0", Some(44490)),
  /// Allows `crate` in paths.
  (accepted, crate_in_paths, "1.30.0", Some(45477)),
+ /// Allows users to provide classes for fenced code block using `class:classname`.
+ (accepted, custom_code_classes_in_docs, "CURRENT_RUSTC_VERSION", Some(79483)),
  /// Allows using `#[debugger_visualizer]` attribute.
  (accepted, debugger_visualizer, "1.71.0", Some(95939)),
  /// Allows rustc to inject a default alloc_error_handler

compiler/rustc_feature/src/unstable.rs

@@ -424,8 +424,6 @@ declare_features! (
  /// Allows function attribute `#[coverage(on/off)]`, to control coverage
  /// instrumentation of that function.
  (unstable, coverage_attribute, "1.74.0", Some(84605)),
- /// Allows users to provide classes for fenced code block using `class:classname`.
- (unstable, custom_code_classes_in_docs, "1.74.0", Some(79483)),
  /// Allows non-builtin attributes in inner attribute position.
  (unstable, custom_inner_attributes, "1.30.0", Some(54726)),
  /// Allows custom test frameworks with `#![test_runner]` and `#[test_case]`.

src/doc/rustdoc/src/unstable-features.md

@@ -624,47 +624,3 @@ add the `--scrape-tests` flag.
 
 This flag enables the generation of links in the source code pages which allow the reader
 to jump to a type definition.
-
-### Custom CSS classes for code blocks
-
-```rust
-#![feature(custom_code_classes_in_docs)]
-
-/// ```custom,{class=language-c}
-/// int main(void) { return 0; }
-/// ```
-pub struct Bar;
-```
-
-The text `int main(void) { return 0; }` is rendered without highlighting in a code block
-with the class `language-c`. This can be used to highlight other languages through JavaScript
-libraries for example.
-
-Without the `custom` attribute, it would be generated as a Rust code example with an additional
-`language-C` CSS class. Therefore, if you specifically don't want it to be a Rust code example,
-don't forget to add the `custom` attribute.
-
-To be noted that you can replace `class=` with `.` to achieve the same result:
-
-```rust
-#![feature(custom_code_classes_in_docs)]
-
-/// ```custom,{.language-c}
-/// int main(void) { return 0; }
-/// ```
-pub struct Bar;
-```
-
-To be noted, `rust` and `.rust`/`class=rust` have different effects: `rust` indicates that this is
-a Rust code block whereas the two others add a "rust" CSS class on the code block.
-
-You can also use double quotes:
-
-```rust
-#![feature(custom_code_classes_in_docs)]
-
-/// ```"not rust" {."hello everyone"}
-/// int main(void) { return 0; }
-/// ```
-pub struct Bar;
-```

src/doc/rustdoc/src/write-documentation/documentation-tests.md

@@ -376,6 +376,44 @@ that the code sample should be compiled using the respective edition of Rust.
 # fn foo() {}
 ```
 
+### Custom CSS classes for code blocks
+
+```rust
+/// ```custom,{class=language-c}
+/// int main(void) { return 0; }
+/// ```
+pub struct Bar;
+```
+
+The text `int main(void) { return 0; }` is rendered without highlighting in a code block
+with the class `language-c`. This can be used to highlight other languages through JavaScript
+libraries for example.
+
+Without the `custom` attribute, it would be generated as a Rust code example with an additional
+`language-C` CSS class. Therefore, if you specifically don't want it to be a Rust code example,
+don't forget to add the `custom` attribute.
+
+To be noted that you can replace `class=` with `.` to achieve the same result:
+
+```rust
+/// ```custom,{.language-c}
+/// int main(void) { return 0; }
+/// ```
+pub struct Bar;
+```
+
+To be noted, `rust` and `.rust`/`class=rust` have different effects: `rust` indicates that this is
+a Rust code block whereas the two others add a "rust" CSS class on the code block.
+
+You can also use double quotes:
+
+```rust
+/// ```"not rust" {."hello everyone"}
+/// int main(void) { return 0; }
+/// ```
+pub struct Bar;
+```
+
 ## Syntax reference
 
 The *exact* syntax for code blocks, including the edge cases, can be found

src/librustdoc/doctest.rs

@@ -1345,7 +1345,6 @@ impl<'a, 'hir, 'tcx> HirCollector<'a, 'hir, 'tcx> {
  def_id.to_def_id(),
  span_of_fragments(&attrs.doc_strings).unwrap_or(sp),
  )),
- self.tcx.features().custom_code_classes_in_docs,
  );
  }
 

src/librustdoc/externalfiles.rs

@@ -46,8 +46,6 @@ impl ExternalHtml {
  edition,
  playground,
  heading_offset: HeadingOffset::H2,
- // For external files, it'll be disabled until the feature is enabled by default.
- custom_code_classes_in_docs: false,
  }
  .into_string()
  );
@@ -63,8 +61,6 @@ impl ExternalHtml {
  edition,
  playground,
  heading_offset: HeadingOffset::H2,
- // For external files, it'll be disabled until the feature is enabled by default.
- custom_code_classes_in_docs: false,
  }
  .into_string()
  );

src/librustdoc/html/markdown.rs

@@ -20,7 +20,6 @@
 //! edition: Edition::Edition2015,
 //! playground: &None,
 //! heading_offset: HeadingOffset::H2,
-//! custom_code_classes_in_docs: true,
 //! };
 //! let html = md.into_string();
 //! // ... something using html
@@ -97,8 +96,6 @@ pub struct Markdown<'a> {
  /// Offset at which we render headings.
  /// E.g. if `heading_offset: HeadingOffset::H2`, then `# something` renders an `<h2>`.
  pub heading_offset: HeadingOffset,
- /// `true` if the `custom_code_classes_in_docs` feature is enabled.
- pub custom_code_classes_in_docs: bool,
 }
 /// A struct like `Markdown` that renders the markdown with a table of contents.
 pub(crate) struct MarkdownWithToc<'a> {
@@ -107,8 +104,6 @@ pub(crate) struct MarkdownWithToc<'a> {
  pub(crate) error_codes: ErrorCodes,
  pub(crate) edition: Edition,
  pub(crate) playground: &'a Option<Playground>,
- /// `true` if the `custom_code_classes_in_docs` feature is enabled.
- pub(crate) custom_code_classes_in_docs: bool,
 }
 /// A tuple struct like `Markdown` that renders the markdown escaping HTML tags
 /// and includes no paragraph tags.
@@ -209,7 +204,6 @@ struct CodeBlocks<'p, 'a, I: Iterator<Item = Event<'a>>> {
  // Information about the playground if a URL has been specified, containing an
  // optional crate name and the URL.
  playground: &'p Option<Playground>,
- custom_code_classes_in_docs: bool,
 }
 
 impl<'p, 'a, I: Iterator<Item = Event<'a>>> CodeBlocks<'p, 'a, I> {
@@ -218,14 +212,12 @@ impl<'p, 'a, I: Iterator<Item = Event<'a>>> CodeBlocks<'p, 'a, I> {
  error_codes: ErrorCodes,
  edition: Edition,
  playground: &'p Option<Playground>,
- custom_code_classes_in_docs: bool,
  ) -> Self {
  CodeBlocks {
  inner: iter,
  check_error_codes: error_codes,
  edition,
  playground,
- custom_code_classes_in_docs,
  }
  }
 }
@@ -257,7 +249,6 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
  lang,
  self.check_error_codes,
  false,
- self.custom_code_classes_in_docs,
  );
  if !parse_result.rust {
  let added_classes = parse_result.added_classes;
@@ -733,7 +724,6 @@ pub(crate) fn find_testable_code<T: doctest::Tester>(
  error_codes: ErrorCodes,
  enable_per_target_ignores: bool,
  extra_info: Option<&ExtraInfo<'_>>,
- custom_code_classes_in_docs: bool,
 ) {
  find_codes(
  doc,
@@ -742,7 +732,6 @@ pub(crate) fn find_testable_code<T: doctest::Tester>(
  enable_per_target_ignores,
  extra_info,
  false,
- custom_code_classes_in_docs,
  )
 }
 
@@ -753,7 +742,6 @@ pub(crate) fn find_codes<T: doctest::Tester>(
  enable_per_target_ignores: bool,
  extra_info: Option<&ExtraInfo<'_>>,
  include_non_rust: bool,
- custom_code_classes_in_docs: bool,
 ) {
  let mut parser = Parser::new(doc).into_offset_iter();
  let mut prev_offset = 0;
@@ -772,7 +760,6 @@ pub(crate) fn find_codes<T: doctest::Tester>(
  error_codes,
  enable_per_target_ignores,
  extra_info,
- custom_code_classes_in_docs,
  )
  }
  }
@@ -1167,29 +1154,6 @@ impl<'a, 'tcx> Iterator for TagIterator<'a, 'tcx> {
  }
 }
 
-fn tokens(string: &str) -> impl Iterator<Item = LangStringToken<'_>> {
- // Pandoc, which Rust once used for generating documentation,
- // expects lang strings to be surrounded by `{}` and for each token
- // to be proceeded by a `.`. Since some of these lang strings are still
- // loose in the wild, we strip a pair of surrounding `{}` from the lang
- // string and a leading `.` from each token.
-
- let string = string.trim();
-
- let first = string.chars().next();
- let last = string.chars().last();
-
- let string =
- if first == Some('{') && last == Some('}') { &string[1..string.len() - 1] } else { string };
-
- string
- .split(|c| c == ',' || c == ' ' || c == '\t')
- .map(str::trim)
- .map(|token| token.strip_prefix('.').unwrap_or(token))
- .filter(|token| !token.is_empty())
- .map(|token| LangStringToken::LangToken(token))
-}
-
 impl Default for LangString {
  fn default() -> Self {
  Self {
@@ -1213,14 +1177,12 @@ impl LangString {
  string: &str,
  allow_error_code_check: ErrorCodes,
  enable_per_target_ignores: bool,
- custom_code_classes_in_docs: bool,
  ) -> Self {
  Self::parse(
  string,
  allow_error_code_check,
  enable_per_target_ignores,
  None,
- custom_code_classes_in_docs,
  )
  }
 
@@ -1229,7 +1191,6 @@ impl LangString {
  allow_error_code_check: ErrorCodes,
  enable_per_target_ignores: bool,
  extra: Option<&ExtraInfo<'_>>,
- custom_code_classes_in_docs: bool,
  ) -> Self {
  let allow_error_code_check = allow_error_code_check.as_bool();
  let mut seen_rust_tags = false;
@@ -1266,11 +1227,7 @@ impl LangString {
  seen_rust_tags = true;
  }
  LangStringToken::LangToken("custom") => {
- if custom_code_classes_in_docs {
- seen_custom_tag = true;
- } else {
- seen_other_tags = true;
- }
+ seen_custom_tag = true;
  }
  LangStringToken::LangToken("test_harness") => {
  data.test_harness = true;
@@ -1361,16 +1318,12 @@ impl LangString {
  data.unknown.push(x.to_owned());
  }
  LangStringToken::KeyValueAttribute(key, value) => {
- if custom_code_classes_in_docs {
- if key == "class" {
- data.added_classes.push(value.to_owned());
- } else if let Some(extra) = extra {
- extra.error_invalid_codeblock_attr(format!(
- "unsupported attribute `{key}`"
- ));
- }
- } else {
- seen_other_tags = true;
+ if key == "class" {
+ data.added_classes.push(value.to_owned());
+ } else if let Some(extra) = extra {
+ extra.error_invalid_codeblock_attr(format!(
+ "unsupported attribute `{key}`"
+ ));
  }
  }
  LangStringToken::ClassAttribute(class) => {
@@ -1380,11 +1333,7 @@ impl LangString {
  }
  };
 
- if custom_code_classes_in_docs {
- call(&mut TagIterator::new(string, extra))
- } else {
- call(&mut tokens(string))
- }
+ call(&mut TagIterator::new(string, extra));
 
  // ignore-foo overrides ignore
  if !ignores.is_empty() {
@@ -1407,7 +1356,6 @@ impl Markdown<'_> {
  edition,
  playground,
  heading_offset,
- custom_code_classes_in_docs,
  } = self;
 
  // This is actually common enough to special-case
@@ -1430,7 +1378,7 @@ impl Markdown<'_> {
  let p = Footnotes::new(p);
  let p = LinkReplacer::new(p.map(|(ev, _)| ev), links);
  let p = TableWrapper::new(p);
- let p = CodeBlocks::new(p, codes, edition, playground, custom_code_classes_in_docs);
+ let p = CodeBlocks::new(p, codes, edition, playground);
  html::push_html(&mut s, p);
 
  s
@@ -1445,7 +1393,6 @@ impl MarkdownWithToc<'_> {
  error_codes: codes,
  edition,
  playground,
- custom_code_classes_in_docs,
  } = self;
 
  let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
@@ -1458,7 +1405,7 @@ impl MarkdownWithToc<'_> {
  let p = HeadingLinks::new(p, Some(&mut toc), ids, HeadingOffset::H1);
  let p = Footnotes::new(p);
  let p = TableWrapper::new(p.map(|(ev, _)| ev));
- let p = CodeBlocks::new(p, codes, edition, playground, custom_code_classes_in_docs);
+ let p = CodeBlocks::new(p, codes, edition, playground);
  html::push_html(&mut s, p);
  }
 
@@ -1902,7 +1849,6 @@ pub(crate) struct RustCodeBlock {
 pub(crate) fn rust_code_blocks(
  md: &str,
  extra_info: &ExtraInfo<'_>,
- custom_code_classes_in_docs: bool,
 ) -> Vec<RustCodeBlock> {
  let mut code_blocks = vec![];
 
@@ -1925,7 +1871,6 @@ pub(crate) fn rust_code_blocks(
  ErrorCodes::Yes,
  false,
  Some(extra_info),
- custom_code_classes_in_docs,
  )
  };
  if !lang_string.rust {