blockwatch-cli 0.16.8__tar.gz → 0.17.0__tar.gz

blockwatch_cli-0.17.0/.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: mennanov # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/CHANGELOG.md

@@ -12,6 +12,37 @@ Releases up to and including v0.3.11 predate this file. Their notes live on the
 
 ## [Unreleased] - ReleaseDate
 
+## [0.17.0] - 2026-11-06
+
+### Added
+
+- Symbols in Dart files (`.dart`). `config.dart#/Invoice/maxLines` points at a field of the class `Invoice`, and
+  `#/kApiVersion` at a variable at the top of the file. Each type is a symbol, and so is each field, method, getter,
+  setter, named constructor and enum value in it. A named extension's members sit under its name. See
+  [Dart](docs/symbols.md#dart).
+
+### Changed
+
+- In a tag that wraps over several comment lines, a longer marker such as `##`, `////` or `---` is now blanked whole,
+  in every language with `#`, `//` or `--` comments. So an attribute value that goes on to such a line loses the extra
+  characters. For example, in Python, a value that goes on to the line `##a` now holds `a` there, not `#a`. The same
+  goes for the stars at the start of a line in a `/* */` comment, such as ` ** `.
+
+### Fixed
+
+- A tag that wraps over several comment lines is no longer reported as malformed when each line starts with a longer
+  marker, such as `///`, `////`, `//!`, `##`, `---` or Python's `#:`. This works in every language with `//`, `#` or
+  `--` comments. In C and C++, it also works with Doxygen's `///<` and `//!<`. In Markdown, a tag can now wrap over
+  several `[//]: # (...)` lines too. In a `/* */` or OCaml `(* *)` comment, it can wrap over lines that start with
+  ` ** `.
+- In Bash and zsh files, a comment that starts with `#!` is no longer skipped, unless it is the shebang on the first
+  line. Before, a tag in such a comment was ignored.
+- A string value with one of these line ends now reads as its language reads it:
+  - In JavaScript and TypeScript, a backslash before U+2028 or U+2029 joins the two lines. Before, the value kept the
+    separator.
+  - In a JavaScript or TypeScript template, a lone `\r` line end is `\n`. Before, the value kept the `\r`.
+  - In a C++ raw string, a `\r\n` line end is `\n`. Before, the value kept the `\r`.
+
 ## [0.16.8] - 2026-11-05
 
 ### Added

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/Cargo.lock

@@ -274,7 +274,7 @@ checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06"
 
 [[package]]
 name = "blockwatch"
-version = "0.16.8"
+version = "0.17.0"
 dependencies = [
  "anyhow",
  "assert-json-diff",

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blockwatch"
-version = "0.16.8"
+version = "0.17.0"
 edition = "2024"
 repository = "https://github.com/mennanov/blockwatch"
 description = "Language agnostic linter that keeps your code and documentation in sync and valid"

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blockwatch-cli
-Version: 0.16.8
+Version: 0.17.0
 Summary: Language agnostic linter that keeps your code and documentation in sync and valid
 Keywords: linter,sync,drift,comments,agents
 Home-Page: https://github.com/mennanov/blockwatch

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/README.md

@@ -90,9 +90,10 @@ Two validators work across files:
 
 Both can point to a block, a whole file, a specific value in a file like `package.json#/version`, a section of a
 Markdown file, an element or attribute in an XML file such as `pom.xml` or a `.csproj`, a constant in a Go, C, C++,
-Python, Rust, TypeScript, JavaScript, Java, C#, Kotlin, Swift or PHP file, a variable in a shell script or a Makefile, a
-field in a Protocol Buffers file, or a value in a Terraform or other HCL file (see [Symbols](docs/symbols.md)). The
-other validators check a single block on their own: the things you'd otherwise have to nitpick in code review.
+Python, Rust, TypeScript, JavaScript, Java, C#, Kotlin, Swift, PHP or Dart file, a variable in a shell script or a
+Makefile, a field in a Protocol Buffers file, or a value in a Terraform or other HCL file (see
+[Symbols](docs/symbols.md)). The other validators check a single block on their own: the things you'd otherwise have
+to nitpick in code review.
 
 <!-- <block name="available-validators"
      same-as="src/validators/mod.rs:validator-registry, docs/validators/README.md:validators-index"
@@ -220,7 +221,7 @@ exclusions, and custom extension mappings.
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.8  # Use latest release
+  rev: v0.17.0  # Use latest release
   hooks:
     - id: blockwatch
 ```
@@ -260,7 +261,7 @@ For plain git hooks, local pre-commit setups, and sandboxing untrusted Lua scrip
 - GraphQL (`.graphql`, `.graphqls`, `.gql`)
 - Groovy (with `.gradle` and `Jenkinsfile` support)
 - HCL (Terraform and OpenTofu: `.tf`, `.tfvars`, `.tofu`, `.hcl`; Nomad: `.nomad`)
-- HTML (with `.xhtml` support)
+- HTML (with `.xhtml` support; comments inside `<script>` and `<style>` are not read)
 - JSON (`.json`, `.jsonc`, `.webmanifest`)
 - Java
 - JavaScript (with `.mjs` and `.cjs` support)
@@ -272,7 +273,7 @@ For plain git hooks, local pre-commit setups, and sandboxing untrusted Lua scrip
 - Markdown
 - Nix
 - OCaml (`.ml`, `.mli`)
-- PHP
+- PHP (comments inside `<script>` and `<style>` are not read)
 - Protocol Buffers (`.proto`)
 - Python (with `.pyi` and `.pyw` support)
 - Ruby (with `Gemfile`, `Rakefile`, `Podfile`, `Brewfile`, `Fastfile`, `Vagrantfile`, `.gemspec`, `.podspec`, `.rake`,

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/docs/ci.md

@@ -19,7 +19,7 @@ To use [pre-commit](https://pre-commit.com), add the hook to `.pre-commit-config
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.8  # Use latest release
+  rev: v0.17.0  # Use latest release
   hooks:
     - id: blockwatch
 ```
@@ -59,7 +59,7 @@ The `blockwatch` hook runs before the commit message exists, so it cannot see a
 
 ```yaml
 - repo: https://github.com/mennanov/blockwatch
-  rev: v0.16.8  # Use latest release
+  rev: v0.17.0  # Use latest release
   hooks:
     - id: blockwatch-commit-msg
 ```

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/docs/cli.md

@@ -557,15 +557,15 @@ Nothing else about the run changes: the same violations are found, and the exit
       "tool": {
         "driver": {
           "name": "blockwatch",
-          "version": "0.16.8",
-          "semanticVersion": "0.16.8",
+          "version": "0.17.0",
+          "semanticVersion": "0.17.0",
           "informationUri": "https://github.com/mennanov/blockwatch",
           "rules": [
             {
               "id": "keep-sorted",
               "name": "keep-sorted",
               "shortDescription": { "text": "Requires the lines of a block to stay in order." },
-              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.16.8/docs/validators/keep-sorted.md"
+              "helpUri": "https://github.com/mennanov/blockwatch/blob/v0.17.0/docs/validators/keep-sorted.md"
             }
           ]
         }

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/docs/symbols.md

@@ -47,6 +47,7 @@ declares, instead of tags in a comment.
 | PHP              | `.php`, `.phtml`                                                                                            | [PHP](#php)                                             |
 | Shell            | `.sh`, `.bash`, `.bashrc`, `.bash_profile`, `.envrc`                                                        | [Shell](#shell)                                         |
 | Makefile         | `Makefile`, `GNUmakefile`, `makefile`, `.mk`, `.mak`                                                        | [Makefile](#makefile)                                   |
+| Dart             | `.dart`                                                                                                     | [Dart](#dart)                                           |
 
 <!-- </block> -->
 
@@ -327,8 +328,8 @@ is `@` and its name, under its element:
 In a code file, each top-level name is a symbol: a constant, a variable, a type, a function or a macro. Its path is
 `#/NAME`.
 With `const MaxPorts = 8` in `consts.go`, `consts.go#/MaxPorts` points at `8`. In Java, C#, Kotlin, Swift, Protocol
-Buffers and PHP, the members of a type are symbols too, under the type's name: `Config.java#/Config/MAX_PORTS`. In
-HCL, each block, attribute and object key is a symbol: `main.tf#/variable/region/default`.
+Buffers, PHP and Dart, the members of a type are symbols too, under the type's name: `Config.java#/Config/MAX_PORTS`.
+In HCL, each block, attribute and object key is a symbol: `main.tf#/variable/region/default`.
 
 - **A value is the initializer as written.** blockwatch never works it out: `20 * 1024 * 1024` stays as it is, and so
   does `0x10`. Use `same-as-pattern` to take the part you need.
@@ -343,7 +344,7 @@ HCL, each block, attribute and object key is a symbol: `main.tf#/variable/region
   where the error is.
 - **A path to a string that blockwatch can't decode stops the run.** Other paths in the file still resolve.
 - **Members are not symbols yet**, such as a method or a field, except in Java, C#, Kotlin, Swift, Protocol Buffers,
-  HCL and PHP.
+  HCL, PHP and Dart.
 
 <!-- </block> -->
 
@@ -424,7 +425,7 @@ int helper(void) { return 0; }
 - **Prototypes and `extern` variables are not symbols.** The definition is.
 - **`template <...>` and `extern "C"` are part of the definition.** The contents of `extern "C" { ... }` are top-level.
 - **Strings follow C's escapes, and strings written one after the other are joined.** A raw string, `R"(...)"`, is its
-  text. `L`, `u` and `U` strings and character literals stay as written.
+  text, with each `\r\n` line end read as `\n`. `L`, `u` and `U` strings and character literals stay as written.
 - **Namespaces, class members and names such as `Foo::bar` are not symbols yet.**
 
 <!-- </block> -->
@@ -1202,6 +1203,75 @@ bin/app: $(SRC)
 
 <!-- </block> -->
 
+## Dart
+
+<!-- <block name="dart-paths"> -->
+
+```dart
+const kApiVersion = '2.1.0';
+int retries = 3, timeout = 30;
+String get greeting => 'hi';
+
+class Invoice {
+  static const int maxLines = 20 * 1024;
+  final int id;
+
+  Invoice(this.id);
+  Invoice.draft() : id = 0;
+
+  int get total => _total;
+  set total(int v) => _total = v;
+  void send() {}
+}
+
+enum Mode { light, dark('d'); const Mode([this.code]); final String? code; }
+
+extension StringX on String { bool get isBlank => trim().isEmpty; }
+```
+
+| Path                 | Points at                                         |
+|----------------------|---------------------------------------------------|
+| `#/kApiVersion`      | `2.1.0`                                           |
+| `#/retries`          | `3`                                               |
+| `#/greeting`         | `hi`                                              |
+| `#/Invoice`          | the whole class                                   |
+| `#/Invoice/maxLines` | `20 * 1024`                                       |
+| `#/Invoice/id`       | `final int id;`, as it has no value               |
+| `#/Invoice/draft`    | the whole constructor                             |
+| `#/Invoice/total`    | a violation, as a getter and a setter share it    |
+| `#/Invoice/send`     | the whole method                                  |
+| `#/Mode/dark`        | `dark('d')`, as an enum value has no value        |
+| `#/Mode/code`        | `final String? code;`                             |
+| `#/StringX/isBlank`  | `trim().isEmpty`                                  |
+
+- **Each top-level variable, function, getter, setter, type and type alias is a symbol, and so is each member of a
+  type**: a field, a method, a getter, a setter, a named constructor or an enum value. Classes, mixins, enums,
+  extensions and extension types are types. Dart has no nested types, so a path has at most two names:
+  `#/Mode/dark`.
+- **A named constructor is a symbol**, as code calls it by its name: `Invoice.draft()` is `#/Invoice/draft`. The
+  unnamed constructor is not, even when it is written `Invoice.new()`. The header of an extension type can declare a
+  named constructor and a field: `extension type Meters.from(double value)` gives `#/Meters/from` and
+  `#/Meters/value`.
+- **A named extension's members sit under its name**: `#/StringX/isBlank`. Two extensions of `String` in one file
+  don't clash. An extension without a name has no symbols.
+- **A getter and a setter with one name are defined twice**, and so are a named constructor and a field with one
+  name, such as `Button.disabled()` and `disabled`. Wrap the one you mean in a block instead.
+- **A variable's value is its initializer, and a getter's is the `v` of `=> v`.** A getter with a block body has no
+  value, and neither has a function, a method or a constructor.
+- **Annotations are part of a definition. Doc comments are not.** In `int a = 1, b = 2;`, each name covers only its
+  own part.
+- **The unnamed constructor, operators, `external` declarations, `library`, `import` and `part` directives, local
+  declarations and closures are not symbols.** A file with `part of` has its own symbols.
+- **Strings follow Dart's escapes.** `'caf\u{e9}'` is `café`. Adjacent strings, such as `'a' "b"`, are joined. A raw
+  string, such as `r'C:\new'`, has no escapes. A `'''` or `"""` string loses a first line that holds only spaces and
+  tabs. Each line end in a string is a line feed, unless a backslash comes before it. A string with `$name` or
+  `${...}` in any part stays as written. A path to a string that Dart rejects, such as `'\u{110000}'`, or to half of a
+  character, such as `'\u{D800}'`, stops the run.
+- **A syntax error stops the run for the member that holds it, and for the type around it.** The other members still
+  resolve.
+
+<!-- </block> -->
+
 ---
 
 [← Return to README](../README.md)

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/setup.py

@@ -6,7 +6,7 @@ setup(
     name='blockwatch-pre-commit-placeholder',
     version='0.0.0',
     # <block name="blockwatch-cli-version" same-as-pattern="blockwatch-cli==(?P<value>\d+\.\d+\.\d+)">
-    install_requires=['blockwatch-cli==0.16.8'],
+    install_requires=['blockwatch-cli==0.17.0'],
     # </block>
     # Without it, setuptools takes the directories under src/ for Python packages.
     packages=[],

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/src/language_parsers/bash.rs

@@ -1,6 +1,6 @@
 use crate::language_parsers::{
-    CommentsParser, LanguageParser, LanguageParserImpl, TreeSitterCommentsParser, comment_visitor,
-    node_text, walk_tree,
+    CommentsParser, LanguageParser, LanguageParserImpl, TreeSitterCommentsParser,
+    blank_line_marker, comment_visitor, node_text, walk_tree,
 };
 use crate::symbols::ScalarValue;
 use crate::symbols::code::{self, CodeLanguage, CodeSymbolsParser, Definition, Value};
@@ -177,18 +177,9 @@ fn declarations<'tree>(declaration: Node<'tree>, source: &str) -> Vec<Definition
         .named_children(&mut cursor)
         .filter(|child| !node_text(child, source).starts_with(['-', '+']))
         .collect();
-    let is_only_name = names.len() == 1;
-    names
-        .into_iter()
-        .filter(|name| name.kind() == "variable_assignment")
-        .filter_map(|name| {
-            let range = if is_only_name {
-                declaration.byte_range()
-            } else {
-                name.byte_range()
-            };
-            assignment(name, range)
-        })
+    code::part_ranges(declaration.byte_range(), names)
+        .filter(|(name, _)| name.kind() == "variable_assignment")
+        .filter_map(|(name, range)| assignment(name, range))
         .collect()
 }
 
@@ -201,11 +192,11 @@ fn comments_parser() -> anyhow::Result<impl CommentsParser> {
                 return None;
             }
             let comment = node_text(node, source);
-            if comment.starts_with("#!") {
-                // Skip shebang.
+            // A shebang works only as the first line of a file. Any other `#!` line is a comment.
+            if node.start_byte() == 0 && comment.starts_with("#!") {
                 None
             } else {
-                Some(comment.replacen("#", " ", 1))
+                blank_line_marker(comment, &["#"])
             }
         }),
     )?;
@@ -508,6 +499,8 @@ echo "Hello"  # This is an inline comment
 # several lines
 
 VALUE=42  # Comment after code
+## A section heading repeats the marker.
+#! Only the first line of a file holds a shebang.
 "#,
             )
             .collect();
@@ -545,9 +538,38 @@ VALUE=42  # Comment after code
                     source_range: 158..178,
                     comment_text: "  Comment after code".to_string()
                 },
+                Comment {
+                    position_range: Position::new(10, 1)..Position::new(10, 41),
+                    source_range: 179..219,
+                    comment_text: "   A section heading repeats the marker.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(11, 1)..Position::new(11, 50),
+                    source_range: 220..269,
+                    comment_text: " ! Only the first line of a file holds a shebang.".to_string()
+                },
             ]
         );
 
         Ok(())
     }
+
+    #[test]
+    fn comment_at_the_start_that_is_not_a_shebang_parse_returns_it() -> anyhow::Result<()> {
+        let mut comments_parser = comments_parser()?;
+
+        // Only a `#!` at the first byte of the file is a shebang.
+        for (source, expected) in [
+            ("# Not a shebang.\n", "  Not a shebang."),
+            ("\n#! Not a shebang either.\n", " ! Not a shebang either."),
+        ] {
+            let texts: Vec<String> = comments_parser
+                .parse(source)
+                .map(|comment| comment.comment_text)
+                .collect();
+
+            assert_eq!(texts, [expected], "{source:?}");
+        }
+        Ok(())
+    }
 }

{blockwatch_cli-0.16.8 → blockwatch_cli-0.17.0}/src/language_parsers/c.rs

@@ -189,10 +189,7 @@ fn declaration_definitions(declaration: Node<'_>, start: usize) -> Vec<Definitio
     let declarators: Vec<Node> = declaration
         .children_by_field_name("declarator", &mut cursor)
         .collect();
-    // In `int a = 1, b = 2;`, each name has its own part, so a change to one does not touch the
-    // other.
-    let alone = declarators.len() == 1;
-    for declarator in declarators {
+    for (declarator, range) in code::part_ranges(start..declaration.end_byte(), declarators) {
         let Some((name, is_function)) = declared_name(declarator) else {
             continue;
         };
@@ -204,11 +201,6 @@ fn declaration_definitions(declaration: Node<'_>, start: usize) -> Vec<Definitio
         if value.is_none() && (is_function || is_extern) {
             continue;
         }
-        let range = if alone {
-            start..declaration.end_byte()
-        } else {
-            declarator.byte_range()
-        };
         definitions.push(Definition::new(Vec::new(), name, range, value));
     }
     definitions
@@ -368,6 +360,9 @@ fn macro_definition<'tree>(
     }))
 }
 
+/// What a macro's body is parsed after, so that it parses as the value of a variable.
+const MACRO_PREFIX: &str = "int x = ";
+
 /// The value of `node`, a `#define` of `name` without parameters, in `source`: its body, read as
 /// the value of a variable. `parser` parses the language of `source`.
 ///
@@ -387,20 +382,40 @@ fn macro_value<'tree>(
     };
     // The grammar keeps the body as one token. As the value of a variable, its strings,
     // parentheses and comments parse as they do in code.
-    const PREFIX: &str = "int x = ";
     let body_text = node_text(&body, source);
-    let text = format!("{PREFIX}{body_text}\n;");
+    let text = format!("{MACRO_PREFIX}{body_text}\n;");
     let tree = parser
         .parse(&text, None)
         .context("failed to parse syntax tree")?;
     let root = tree.root_node();
-    let in_file = |at: usize| body.start_byte() + at - PREFIX.len();
-    // The body holds a `//` comment at its end.
+    let written = written_body(body_text, root);
+    // A body that is not one value, such as `static inline`, or that the grammar can't read,
+    // such as an unclosed string, is kept as written.
+    let initializer = root
+        .child(0)
+        .and_then(|declaration| declaration.child_by_field_name("declarator"))
+        .and_then(|declarator| declarator.child_by_field_name("value"))
+        .filter(|value| {
+            !root.has_error() && value.end_byte() == MACRO_PREFIX.len() + written.len()
+        });
+    Ok(match initializer {
+        Some(initializer) => initializer_value(initializer, &text, body, source),
+        None => Value::Read(ScalarValue {
+            text: written.to_string(),
+            byte_range: body.start_byte()..body.start_byte() + written.len(),
+        }),
+    })
+}
+
+/// `body_text`, the body of a macro, without the `//` comment at its end and the backslashes that
+/// continue it onto the next lines. `root` is the root of the body parsed after
+/// [`MACRO_PREFIX`].
+fn written_body<'a>(body_text: &'a str, root: Node) -> &'a str {
     let mut written = body_text.trim_end();
     if let Some(comment) = root
         .descendant_for_byte_range(
-            PREFIX.len() + written.len() - 1,
-            PREFIX.len() + written.len(),
+            MACRO_PREFIX.len() + written.len() - 1,
+            MACRO_PREFIX.len() + written.len(),
         )
         .filter(|last| last.kind() == "comment")
     {
@@ -408,27 +423,26 @@ fn macro_value<'tree>(
             clippy::string_slice,
             reason = "tree-sitter nodes start on whole characters"
         )]
-        let before = body_text[..comment.start_byte() - PREFIX.len()].trim_end();
+        let before = body_text[..comment.start_byte() - MACRO_PREFIX.len()].trim_end();
         written = before;
     }
     // A backslash can continue the body onto a line that holds only a comment.
     while let Some(continued) = written.strip_suffix('\\') {
         written = continued.trim_end();
     }
-    // A body that is not one value, such as `static inline`, or that the grammar can't read,
-    // such as an unclosed string, is kept as written.
-    let initializer = root
-        .child(0)
-        .and_then(|declaration| declaration.child_by_field_name("declarator"))
-        .and_then(|declarator| declarator.child_by_field_name("value"))
-        .filter(|value| !root.has_error() && value.end_byte() == PREFIX.len() + written.len());
-    let Some(initializer) = initializer else {
-        return Ok(Value::Read(ScalarValue {
-            text: written.to_string(),
-            byte_range: body.start_byte()..body.start_byte() + written.len(),
-        }));
-    };
-    Ok(match code::node_value(initializer, &text, &decode_string) {
+    written
+}
+
+/// The value of `initializer`, the value in `text`, which is the macro body `body` parsed after
+/// [`MACRO_PREFIX`]. Its positions are where the body is in `source`.
+fn initializer_value<'tree>(
+    initializer: Node,
+    text: &str,
+    body: Node<'tree>,
+    source: &str,
+) -> Value<'tree> {
+    let in_file = |at: usize| body.start_byte() + at - MACRO_PREFIX.len();
+    match code::node_value(initializer, text, &decode_string) {
         Ok(value) => Value::Read(ScalarValue {
             text: value.text,
             byte_range: in_file(value.byte_range.start)..in_file(value.byte_range.end),
@@ -439,7 +453,7 @@ fn macro_value<'tree>(
             let at = in_file(string.start_byte());
             Value::Undecodable(Position::new(line, character_column_at(source, at)), error)
         }
-    })
+    }
 }
 
 /// Decodes a C or C++ string literal, or several written one after the other, which C joins.
@@ -457,8 +471,9 @@ fn decode_string(node: &Node, source: &str) -> anyhow::Result<Option<String>> {
             _ => Ok(None),
         },
         "raw_string_literal" => match node.child(0).map(|open| open.kind()) {
+            // C++ reads a `\r\n` line end as `\n`, in a raw string too. A lone `\r` stays.
             Some("R\"" | "u8R\"") => Ok(code::child(*node, "raw_string_content")
-                .map(|content| node_text(&content, source).to_string())),
+                .map(|content| node_text(&content, source).replace("\r\n", "\n"))),
             _ => Ok(None),
         },
         _ => Ok(None),
@@ -513,7 +528,11 @@ fn push_escape(escape: &str, bytes: &mut Vec<u8>) -> anyhow::Result<()> {
 
 fn comments_parser() -> anyhow::Result<impl CommentsParser> {
     let cpp_language = tree_sitter_c::LANGUAGE.into();
-    let parser = language_parsers::c_style_comments_parser(&cpp_language, "comment")?;
+    let parser = language_parsers::c_style_comments_parser(
+        &cpp_language,
+        &["comment"],
+        language_parsers::DOXYGEN_MARKERS,
+    )?;
     Ok(parser)
 }
 
@@ -830,14 +849,19 @@ char C = 'c';
 
     #[test]
     fn raw_strings_parse_symbols_returns_the_text_of_narrow_ones() -> anyhow::Result<()> {
-        let source = r#"const char *Raw = R"d(a"b)d";
+        // A Rust raw string can't hold a carriage return, so the lines with `\r` are escaped.
+        let source = concat!(
+            r#"const char *Raw = R"d(a"b)d";
 const char *Utf8Raw = u8R"(é)";
 const char *WideRaw = LR"(w)";
 const char *Lines = R"(a
 b)";
 const char *Empty = R"()";
 #define MACRO_RAW R"(x")"
-"#;
+"#,
+            "const char *CrlfLines = R\"(a\r\nb)\";\n",
+            "const char *CrLines = R\"(a\rb)\";\n"
+        );
 
         assert_eq!(
             values(&cpp(source)?, source),
@@ -848,6 +872,9 @@ const char *Empty = R"()";
                 value("/Lines", "a\nb"),
                 value("/Empty", ""),
                 value("/MACRO_RAW", r#"x""#),
+                // C++ reads a `\r\n` line end as `\n`, in a raw string too. A lone `\r` stays.
+                value("/CrlfLines", "a\nb"),
+                value("/CrLines", "a\rb"),
             ]
         );
         Ok(())
@@ -1132,6 +1159,16 @@ mod tests {
                 return 0;
             }
 /// Triple slash comment.
+//! Doxygen reads this marker as a doc comment, in the Qt style.
+//// A banner line repeats the marker.
+int a; ///< Doxygen documents the member before this comment.
+int b; //!< Doxygen documents the member before this comment, in the Qt style.
+//!Doxygen reads this marker with no space after it too.
+int c; ///<
+//<block name="x"> A tag right after the marker keeps its first character.
+/**
+ ** A comment that starts each line with two stars.
+ **/
             "#,
             )
             .collect();
@@ -1164,7 +1201,49 @@ mod tests {
                 Comment {
                     position_range: Position::new(20, 1)..Position::new(20, 26),
                     source_range: 468..493,
-                    comment_text: "  / Triple slash comment.".to_string()
+                    comment_text: "    Triple slash comment.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(21, 1)..Position::new(21, 65),
+                    source_range: 494..558,
+                    comment_text: "    Doxygen reads this marker as a doc comment, in the Qt style.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(22, 1)..Position::new(22, 39),
+                    source_range: 559..597,
+                    comment_text: "     A banner line repeats the marker.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(23, 8)..Position::new(23, 62),
+                    source_range: 605..659,
+                    comment_text: "     Doxygen documents the member before this comment.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(24, 8)..Position::new(24, 79),
+                    source_range: 667..738,
+                    comment_text: "     Doxygen documents the member before this comment, in the Qt style.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(25, 1)..Position::new(25, 57),
+                    source_range: 739..795,
+                    comment_text: "   Doxygen reads this marker with no space after it too.".to_string()
+                },
+                Comment {
+                    position_range: Position::new(26, 8)..Position::new(26, 12),
+                    source_range: 803..807,
+                    comment_text: "    ".to_string()
+                },
+                Comment {
+                    position_range: Position::new(27, 1)..Position::new(27, 75),
+                    source_range: 808..882,
+                    comment_text: r#"  <block name="x"> A tag right after the marker keeps its first character."#
+                        .to_string()
+                },
+                Comment {
+                    position_range: Position::new(28, 1)..Position::new(30, 5),
+                    source_range: 883..943,
+                    comment_text: "   \n    A comment that starts each line with two stars.\n    "
+                        .to_string()
                 },
             ]
         );