Prune commentary and stale Rust port notes

app-rust/src/client/highlight/languages.rs

@@ -1,8 +1,3 @@
-//! A language the highlighter can colour, and the data-driven [`Rules`] each
-//! one scans by. Ported from `app/.../Languages.kt`; see that file's doc for
-//! why nearly every language is a row of data read by one shared scanner,
-//! with Markdown the one exception (`super::markdown`).
-
 use std::collections::HashSet;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -32,8 +27,6 @@ pub enum Language {
 }
 
 impl Language {
-    /// Every value, for the same exhaustiveness check the Kotlin test runs
-    /// (`Language.entries`).
     pub const ALL: [Language; 22] = [
         Language::C,
         Language::Coffeescript,
@@ -60,24 +53,14 @@ impl Language {
     ];
 }
 
-/// What [`super::scan`] needs to know about one language -- data, not code,
-/// so that adding a language is a row here rather than a branch anywhere.
 #[derive(Debug, Clone, Default)]
 pub struct Rules {
-    /// Words drawn as keywords. Only plain words; the scanner cannot reach
-    /// anything else.
     pub keywords: HashSet<&'static str>,
-    /// Tokens that open a comment running to the end of the line.
     pub line_comments: Vec<&'static str>,
-    /// Whether `line_comments` count only at the start of a word. The shells
-    /// need it: `$#`, `${#x}` and `a#b` are not comments.
     pub line_comments_at_word_start: bool,
     pub block_comment: Option<BlockComment>,
-    /// The string forms. The longest opener that matches wins, so `"""` is
-    /// tried before `"`.
     pub quotes: Vec<Quote>,
     pub attributes: Attributes,
-    /// Rust and RON: an optional `b`, `r`, n hashes, `"`, closing at `"` and n hashes.
     pub raw_strings: bool,
     /// Rust: `'` opens a character literal only when a backslash or one
     /// character and a `'` follow. Otherwise it is a lifetime or a label.
@@ -91,8 +74,6 @@ pub struct BlockComment {
     pub nests: bool,
 }
 
-/// One string form. `escapes` is whether a backslash escapes the closer
-/// (and itself).
 #[derive(Debug, Clone, Copy)]
 pub struct Quote {
     pub open: &'static str,
@@ -100,18 +81,13 @@ pub struct Quote {
     pub escapes: bool,
 }
 
-/// What opens a metadata span, of the shapes that exist across these languages.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum Attributes {
     #[default]
     None,
-    /// `@` and a word: Kotlin and Java annotations, Python decorators.
     AtWord,
-    /// `#[` or `#![` through the matching `]`: Rust and RON attributes.
     HashBracket,
-    /// `#` at the start of a line, to the end of it: the C preprocessor.
     HashLine,
-    /// `[` at the start of a line through the matching `]`: a TOML table header.
     LineBracket,
 }
 
@@ -151,10 +127,6 @@ fn words(list: &'static str) -> HashSet<&'static str> {
     list.split_whitespace().collect()
 }
 
-/// The rules for one language. A `match` rather than a lazily-built map --
-/// there is no once-per-process cost worth paying for in a language table
-/// this small, and it sidesteps the Kotlin version's own workaround for
-/// property initialization order.
 pub fn rules_for(language: Language) -> Rules {
     match language {
         Language::C => Rules {
@@ -180,8 +152,6 @@ pub fn rules_for(language: Language) -> Rules {
             quotes: vec![DOUBLE, SINGLE],
             ..Default::default()
         },
-        // `###` opens and closes a block comment and `#` opens a line one,
-        // which is why the scanner tries the block opener first.
         Language::Coffeescript => Rules {
             keywords: words(KEYWORDS_COFFEESCRIPT),
             line_comments: vec!["#"],
@@ -318,7 +288,6 @@ pub fn rules_for(language: Language) -> Rules {
             keywords: words(KEYWORDS_SHELL),
             line_comments: vec!["#"],
             line_comments_at_word_start: true,
-            // A shell's single quotes are literal: `'a\'` is not one string.
             quotes: vec![
                 DOUBLE,
                 Quote {
@@ -373,16 +342,10 @@ pub fn rules_for(language: Language) -> Rules {
             attributes: Attributes::AtWord,
             ..Default::default()
         },
-        // Markdown has no token rules; see `super::markdown::scan_markdown`.
         Language::Markdown => Rules::default(),
     }
 }
 
-// The keyword sets. Every list below other than RON, TOML, fish and JSON
-// came from dev.snipme:highlights 1.1.0 (Apache-2.0), the library the
-// Kotlin scanner replaced, so that no fence which was coloured there turns
-// plain here either.
-
 const KEYWORDS_C: &str =
     "auto break case char const continue default do double else enum extern float for goto if
     int long register return short signed sizeof static struct switch typedef union unsigned
@@ -416,9 +379,6 @@ const KEYWORDS_DART: &str =
     required rethrow return sealed set show static super switch this throw true try var void
     when with while yield";
 
-/// fish is not in the library at all, so its fences are drawn plain today.
-/// The list is the shell's own words, which is what a fish fence is mostly
-/// made of.
 const KEYWORDS_FISH: &str =
     "and begin break builtin case command continue else end exec for function if in not or
     return switch while set echo test string math read source";
@@ -466,7 +426,6 @@ const KEYWORDS_PYTHON: &str =
     for from global if import in is lambda nonlocal not or pass raise return try while with
     yield";
 
-/// RON is not in the library either; these are the words a RON file can hold.
 const KEYWORDS_RON: &str = "true false Some None inf NaN";
 
 const KEYWORDS_RUBY: &str =
@@ -495,8 +454,6 @@ const KEYWORDS_SWIFT: &str =
     nonmutating optional override postfix precedence prefix Protocol required right set some Type
     unowned weak willSet";
 
-/// TOML is not in the library; `inf` and `nan` are values rather than
-/// names, like the booleans.
 const KEYWORDS_TOML: &str = "true false inf nan";
 
 const KEYWORDS_TYPESCRIPT: &str =
@@ -518,8 +475,6 @@ pub fn fence_language(name: Option<&str>) -> Option<Language> {
         .map(|(_, language)| *language)
 }
 
-/// The highlighter's language for a *file*, from its name.
-///
 /// The extension is the part after the *last* dot, which is what makes
 /// `build.gradle.kts` Kotlin. A leading dot is not one: `.bashrc` has no
 /// extension, it has a name that starts with a dot. A name with no dot at