@d3lm/lint-preset 1.5.6 → 1.6.0

package/dist/comments.js

@@ -1,6 +1,71 @@
 // src/comments/analyze.ts
 import { parseSync } from "oxc-parser";
 
+// src/comments/rust.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { fileURLToPath } from "url";
+var BINARY_NAME = "comments";
+function platformSuffixes() {
+  const { platform, arch } = process;
+  switch (platform) {
+    case "darwin": {
+      return [`darwin-${arch}`, "darwin-universal"];
+    }
+    case "linux": {
+      return arch === "arm" ? ["linux-arm-gnueabihf", "linux-arm-musleabihf"] : [`linux-${arch}-gnu`, `linux-${arch}-musl`];
+    }
+    case "win32": {
+      return [`win32-${arch}-msvc`, `win32-${arch}-gnu`];
+    }
+    default: {
+      return [`${platform}-${arch}`];
+    }
+  }
+}
+function findBinaries() {
+  const names = platformSuffixes().map((suffix) => `${BINARY_NAME}.${suffix}.node`);
+  for (let directory = path.dirname(fileURLToPath(import.meta.url)); ; directory = path.dirname(directory)) {
+    const found = names.map((name) => path.join(directory, "native", name)).filter((file) => existsSync(file));
+    if (found.length > 0) {
+      return found;
+    }
+    if (path.dirname(directory) === directory) {
+      return [];
+    }
+  }
+}
+var binding;
+function loadBinding() {
+  if (binding) {
+    return binding;
+  }
+  const require2 = createRequire(import.meta.url);
+  const errors = [];
+  for (const file of findBinaries()) {
+    try {
+      binding = require2(file);
+      return binding;
+    } catch (error) {
+      errors.push(`${file}: ${error.message}`);
+    }
+  }
+  const reason = errors.length > 0 ? `, and loading it failed (${errors.join("; ")})` : "";
+  throw new Error(
+    `comments: Rust files need the native addon for ${process.platform}-${process.arch}${reason}. Build it with \`pnpm run build:native\`, or leave \`.rs\` out of \`extensions\`.`
+  );
+}
+function scanRust(source) {
+  return loadBinding().scanRust(source);
+}
+function rustFingerprint(source) {
+  return loadBinding().rustFingerprint(source);
+}
+function isRustCode(text) {
+  return loadBinding().isRustCode(text);
+}
+
 // src/comments/style.ts
 var BANNER = /^(?!#{1,6}\s)([-=*#_~+/\\])\1{3,}|([-=*#_~])\2{3,}\s*$/;
 var COLUMN_RULE = /^([-=_~])\1*(?:\s+\1+)+$/;
@@ -124,12 +189,94 @@ function findCodeSpanEnd(text, start) {
   }
   return -1;
 }
+function isEscaped(text, index) {
+  let backslashes = 0;
+  while (text[index - 1 - backslashes] === "\\") {
+    backslashes += 1;
+  }
+  return backslashes % 2 === 1;
+}
+function findUnescaped(text, char, start) {
+  for (let index = start; index < text.length; index += 1) {
+    if (text[index] === "\\") {
+      index += 1;
+    } else if (text[index] === char) {
+      return index;
+    }
+  }
+  return -1;
+}
+function findClosingBracket(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    switch (text[index]) {
+      case "\\": {
+        index += 1;
+        break;
+      }
+      case "`": {
+        const close = findCodeSpanEnd(text, index);
+        index = close === -1 ? index + backtickRun(text, index) - 1 : close;
+        break;
+      }
+      case "[": {
+        depth += 1;
+        break;
+      }
+      case "]": {
+        depth -= 1;
+        if (depth === 0) {
+          return index;
+        }
+        break;
+      }
+    }
+  }
+  return -1;
+}
+function findDestinationEnd(text, start) {
+  let depth = 0;
+  for (let index = start; index < text.length; index += 1) {
+    const char = text[index];
+    let close = -1;
+    if (char === "\\") {
+      index += 1;
+    } else if (char === "<" && text.slice(start + 1, index).trim() === "") {
+      close = findUnescaped(text, ">", index + 1);
+    } else if ((char === '"' || char === "'") && /\s/.test(text[index - 1])) {
+      close = findUnescaped(text, char, index + 1);
+    } else if (char === "(") {
+      depth += 1;
+    } else if (char === ")" && --depth === 0) {
+      return index;
+    }
+    index = close === -1 ? index : close;
+  }
+  return -1;
+}
+function findLinkEnd(text, start) {
+  const close = findClosingBracket(text, start);
+  if (close === -1 || text[close + 1] !== "(") {
+    return close;
+  }
+  const end = findDestinationEnd(text, close + 1);
+  return end === -1 ? close : end;
+}
 function tokenize(text) {
+  return splitWords(text, true);
+}
+function splitWords(text, keepLinks) {
   const tokens = [];
   let current = "";
   let index = 0;
   while (index < text.length) {
     const char = text[index];
+    const linkEnd = keepLinks && char === "[" && !isEscaped(text, index) ? findLinkEnd(text, index) : -1;
+    if (linkEnd !== -1) {
+      current += splitWords(text.slice(index, linkEnd + 1), false).join(" ");
+      index = linkEnd + 1;
+      continue;
+    }
     const close = char === "`" ? findCodeSpanEnd(text, index) : char === "{" ? findClosingBrace(text, index) : -1;
     if (char === "`" && close === -1) {
       const run = backtickRun(text, index);
@@ -225,7 +372,7 @@ function isOrphan(previous, token) {
   return opensAside(token) || endsClause(previous) && !CLAUSE_END.test(token);
 }
 function startsBlock(token) {
-  return /^(?:[-*+>]|\d+[.)]|#{1,6})$/.test(token) || /^(?:@[A-Za-z]|`{3}|~{3}|\||<\/?[A-Za-z])/.test(token);
+  return /^(?:\+|-+|=+|\*+|_{3,}|\d+[.)]|#{1,6})$/.test(token) || /^(?:>|@[A-Za-z]|`{3}|~{3}|\||<(?:\/?[A-Za-z]|[!?]))/.test(token);
 }
 function bindLineStarts(tokens, startsLine2 = startsBlock) {
   const units = [];
@@ -663,6 +810,7 @@ var NAMED_TAGS = /* @__PURE__ */ new Set(["arg", "argument", "param", "prop", "p
 var LINE_DIRECTIVE = /^\s*(?:(?:eslint|oxlint|stylelint)-(?:disable(?:-next-line|-line)?|enable)\b|eslint-env\b|@ts-(?:ignore|expect-error|nocheck|check)\b|@jsx\w*\b|@vite-ignore\b|[@#]__[A-Z_]+__|@(?:vitest|jest)-environment\b|(?:istanbul|c8|v8)\s+ignore\b|prettier-ignore\b|biome-ignore\b|deno-(?:lint-ignore|fmt-ignore)(?:-file)?\b|tslint:|(?:c[sS]pell|spell-?checker)\s*:|(?:webpack|turbopack)[A-Z][a-zA-Z]*\s*:|vim?:\s|#(?:region|endregion)\b|<reference\s)/;
 var BLOCK_DIRECTIVE = /^\s*(?:eslint\s|globals?\s|exported\s|jshint\s|jslint\s|type\s*:)/;
 var LEGAL_COMMENT = /^!|@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
+var RUST_LEGAL_COMMENT = /@license\b|@preserve\b|\bcopyright\s+(?:\(c\)|©|\d{4})/i;
 var DEFINITION = /^(?:``|[\w$.[\]]+(?:[ -][\w$.[\]]+)?)(?: [-–]|:) \S/;
 var BOX_DRAWING = /[\u2500-\u257F]/;
 var TABLE_DELIMITER = /^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)+\|?$/;
@@ -737,12 +885,35 @@ ${text}
   }
   return properties.length > 1 || text.trimEnd().endsWith(",") || properties.some((property) => property.type === "Property" && CODE_VALUES.has(property.value.type));
 }
-function isCode(texts) {
-  const text = texts.map((line) => line.replace(LIST_MARKER, "")).join("\n");
-  return parsesAsStatements(text) || parsesAsProperties(text);
+function isCode(texts, language) {
+  return language.isCode(texts.map((line) => line.replace(LIST_MARKER, "")).join("\n"));
 }
 function isCodeLine(text) {
-  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+  return text.endsWith("{") || text.endsWith(";") && (/[()[\]{}=<>]/.test(text) || !/\s/.test(text)) || /^[}\])]/.test(text);
+}
+var JAVASCRIPT = {
+  name: "javascript",
+  isCode: (text) => parsesAsStatements(text) || parsesAsProperties(text),
+  isCodeLine: (text) => {
+    return isCodeLine(text) || /^(?:const|let|var)\s+[\w$]+\s*[:=]/.test(text) || /^(?:import|export)\s.*(?:\sfrom\s|[{}])/.test(text);
+  },
+  legal: LEGAL_COMMENT,
+  blockDirective: BLOCK_DIRECTIVE,
+  tags: true,
+  joinsCodeSpans: true
+};
+var RUST = {
+  name: "rust",
+  isCode: (text) => isRustCode(text),
+  isCodeLine: (text) => {
+    return isCodeLine(text) || /^let\s+(?:mut\s+)?\w+\s*[:=]/.test(text) || /^(?:pub(?:\([\w:\s]+\))?\s+)?(?:const|static(?:\s+mut)?)\s+[A-Z_\d]+\s*:/.test(text) || /^(?:pub(?:\([\w:\s]+\))?\s+)?use\s+[\w:]*::/.test(text) || /^#!?\[/.test(text);
+  },
+  legal: RUST_LEGAL_COMMENT,
+  tags: false,
+  joinsCodeSpans: false
+};
+function languageOf(filename) {
+  return filename.endsWith(".rs") ? RUST : JAVASCRIPT;
 }
 function layoutReason(prose, raw) {
   if (prose.startsWith("|") || TABLE_DELIMITER.test(prose)) {
@@ -756,8 +927,10 @@ function layoutReason(prose, raw) {
   }
   return void 0;
 }
+var THEMATIC_BREAK = /^(?:(?:\*\s*){3,}|(?:-\s*){3,}|(?:_\s*){3,})$/;
 function isMarkup(prose) {
-  return /^#{1,6}\s/.test(prose) || /^\[[^\]]+\]:/.test(prose) || /^<\/?[a-z]/i.test(prose) || /^>(?:\s|$)/.test(prose);
+  const text = prose.replace(LIST_MARKER, "");
+  return /^#{1,6}(?:\s|$)/.test(text) || /^\[[^\]]+\]:/.test(text) || /^<(?:\/?[a-z]|[!?])/i.test(text) || text.startsWith(">") || /^(?:=+|-+)$/.test(prose) || THEMATIC_BREAK.test(prose);
 }
 function mask(text) {
   return text.replaceAll(/[^\n]/g, "x");
@@ -784,11 +957,14 @@ function hasAlignedColumns(lines) {
   }
   return false;
 }
-function structureOf(lines) {
+function structureOf(lines, language) {
   const trimmed = lines.map((line) => line.text.trim()).join("\n");
   const texts = replaceKeepingLines(trimmed, CODE_SPAN, "``").split("\n");
   const proseLines = stripNonProse(trimmed).split("\n");
-  if (isCode(lines.map((line) => line.text.trim()))) {
+  if (isCode(
+    lines.map((line) => line.text.trim()),
+    language
+  )) {
     return { tier: "code", reason: "code" };
   }
   let layout;
@@ -797,7 +973,7 @@ function structureOf(lines) {
   for (const [position, line] of texts.entries()) {
     const prose = proseLines[position].trim();
     layout ??= layoutReason(prose, lines[position]?.text ?? "");
-    if (isCodeLine(line.trim())) {
+    if (language.isCodeLine(line.trim())) {
       codeLike = true;
     } else if (isMarkup(prose)) {
       manual ??= "markup";
@@ -836,7 +1012,7 @@ var FenceTracker = class {
     return true;
   }
 };
-function segment(lines) {
+function segment(lines, language) {
   const paragraphs = [];
   const fence = new FenceTracker();
   let current;
@@ -873,6 +1049,10 @@ function segment(lines) {
       continue;
     }
     if (line.verbatim) {
+      if (fence.next(text)) {
+        start("code", line, "", "code block");
+        continue;
+      }
       start("code", line, "", "directive");
       flush();
       continue;
@@ -897,7 +1077,7 @@ function segment(lines) {
       }
       continue;
     }
-    const tag = JSDOC_TAG.exec(text);
+    const tag = language.tags ? JSDOC_TAG.exec(text) : null;
     if (tag) {
       start("tag", line, "", PROSE_TAGS.has(tag[1]) ? void 0 : `@${tag[1]} tag`);
       inCodeTag = CODE_TAGS.has(tag[1]);
@@ -1004,7 +1184,19 @@ function byLine(issues) {
 function sameLayout(a, b) {
   return a.length === b.length && a.every((words, position) => words.join(" ") === b[position].join(" "));
 }
-function analyzeParagraph(paragraph, options) {
+function splitTokenLine(lines, tokens) {
+  let next = 0;
+  return lines.findIndex((words) => {
+    const line = words.join(" ");
+    let text = "";
+    while (text.length < line.length && next < tokens.length) {
+      text += `${text ? " " : ""}${tokens[next]}`;
+      next += 1;
+    }
+    return text !== line;
+  });
+}
+function analyzeParagraph(paragraph, options, language) {
   const first = paragraph.lines[0];
   const last = paragraph.lines.at(-1) ?? first;
   const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
@@ -1031,7 +1223,8 @@ function analyzeParagraph(paragraph, options) {
     const structure2 = structureOf(
       prose.lines.map((line) => {
         return { ...line, text: stripBlockSyntax(line.text) };
-      })
+      }),
+      language
     );
     const issues2 = keptIssues(prose, structure2, options);
     return { ...base, reflowable: false, reason: paragraph.reason, issues: issues2, suggestion: null };
@@ -1040,7 +1233,7 @@ function analyzeParagraph(paragraph, options) {
     const issues2 = keptIssues(paragraph, structure2, options);
     return { ...base, reflowable: false, reason: structure2.reason, issues: issues2, suggestion: null };
   };
-  const structure = structureOf(paragraph.lines);
+  const structure = structureOf(paragraph.lines, language);
   if (structure) {
     return keep(structure);
   }
@@ -1072,10 +1265,14 @@ function analyzeParagraph(paragraph, options) {
   if (!units.every((unit) => staysInLimit(unit))) {
     return keep({ tier: "manual", reason: "unbreakable text across lines" });
   }
+  const text = currentLines.map((words) => words.join(" ")).join("\n");
+  if (!language.joinsCodeSpans && [...text.matchAll(CODE_SPAN)].some((span) => span[0].includes("\n"))) {
+    return keep({ tier: "manual", reason: "code span across lines" });
+  }
   const bodyOf = (lines) => {
     return lines.map((words, position) => {
-      const text = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
-      return { ...first, text, verbatim: false, hardBreak: HARD_BREAK.test(text) };
+      const text2 = `${position === 0 ? paragraph.marker : hang}${words.join(" ")}`;
+      return { ...first, text: text2, verbatim: false, hardBreak: HARD_BREAK.test(text2) };
     });
   };
   const settle = (settings, extra = 0) => {
@@ -1083,11 +1280,11 @@ function analyzeParagraph(paragraph, options) {
     let { even: even2, wrapped: wrapped2 } = layOut(current, settings, extra);
     for (; ; ) {
       const body = bodyOf(wrapped2);
-      const rewrap = structureOf(body);
+      const rewrap = structureOf(body, language);
       if (!rewrap) {
         return { even: even2, wrapped: wrapped2 };
       }
-      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1)) !== void 0);
+      const tipping = body.findIndex((_, position) => structureOf(body.slice(0, position + 1), language) !== void 0);
       const start = wrapped2.slice(0, Math.max(tipping, 1)).flat().length;
       const pair = `${current[start - 1]} ${current[start]}`;
       if (body.length < 2 || !staysInLimit(pair)) {
@@ -1113,6 +1310,7 @@ function analyzeParagraph(paragraph, options) {
   }
   const { even, wrapped } = layout;
   const matchesLayout = sameLayout(wrapped, currentLines);
+  const isVerdict = (issue) => ISSUE_TIERS[issue.type] === "verdict";
   const lineIssues = [];
   const overflow = options.maxWidth === void 0 ? [] : overflowIssues(paragraph.lines, options);
   if (!matchesLayout) {
@@ -1171,8 +1369,11 @@ function analyzeParagraph(paragraph, options) {
         lineIssues.push({ type: "unbalanced", line });
       }
     }
+    const splitLine = splitTokenLine(currentLines, tokens);
+    if (splitLine !== -1 && overflow.length === 0 && !lineIssues.some((issue) => isVerdict(issue))) {
+      lineIssues.push({ type: "unbalanced", line: splitLine });
+    }
   }
-  const isVerdict = (issue) => ISSUE_TIERS[issue.type] === "verdict";
   const matchesWiderLayout = () => {
     for (let extra = 1; extra <= layoutOptions.tolerance; extra += 1) {
       const wider = layoutAt(extra);
@@ -1191,6 +1392,18 @@ function analyzeParagraph(paragraph, options) {
   const issues = byLine([...overflow, ...wrapIssues, ...styleIssues(paragraph, options)]);
   return { ...base, reflowable: true, issues, suggestion };
 }
+var LINE_COMMENT = "line comment";
+function analyzeLineParagraph(paragraph, options, language) {
+  const first = paragraph.lines[0];
+  const last = paragraph.lines.at(-1) ?? first;
+  const base = { kind: paragraph.kind, startLine: first.index + 1, endLine: last.index + 1 };
+  if (paragraph.kind === "code") {
+    return { ...base, reflowable: false, reason: paragraph.reason, issues: [], suggestion: null };
+  }
+  const tier = structureOf(paragraph.lines, language)?.tier;
+  const issues = tier === "code" || tier === "layout" ? [] : overflowIssues(paragraph.lines, options);
+  return { ...base, reflowable: false, reason: LINE_COMMENT, issues, suggestion: null };
+}
 function computeLineStarts(source) {
   const starts = [0];
   for (let index = 0; index < source.length; index += 1) {
@@ -1216,31 +1429,42 @@ function lineOf(lineStarts, offset) {
 function stripCarriageReturn(line) {
   return line.endsWith("\r") ? line.slice(0, -1) : line;
 }
-function shapeBlock(comment, sourceLines, lineStarts) {
+function blockKind(comment, language) {
+  if (language.name === "rust") {
+    return comment.doc ? `${comment.doc}-block-doc` : "block";
+  }
+  return comment.value.startsWith("*") ? "jsdoc" : "block";
+}
+function wholeComment(shape, lines, paragraphKind, reason) {
+  const otherLines = lines.map((text, offset) => {
+    return { index: shape.startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
+  });
+  return { ...shape, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
+}
+function isLegal(value, language) {
+  return language.legal.test(replaceKeepingLines(value, CODE_SPAN, "``"));
+}
+function shapeBlock(comment, sourceLines, lineStarts, language) {
   const startLine = lineOf(lineStarts, comment.start);
   const endLine = lineOf(lineStarts, comment.end - 1);
-  const kind = comment.value.startsWith("*") ? "jsdoc" : "block";
+  const shape = { kind: blockKind(comment, language), startLine, endLine };
   const lines = sourceLines.slice(startLine, endLine + 1);
-  const wholeComment = (paragraphKind, reason) => {
-    const otherLines = lines.map((text, offset) => {
-      return { index: startLine + offset, prefix: "", text, verbatim: false, hardBreak: false };
-    });
-    return { kind, startLine, endLine, paragraphs: [{ kind: paragraphKind, marker: "", reason, lines: otherLines }] };
-  };
-  const value = comment.value.replace(/^\*/, "");
-  if (LEGAL_COMMENT.test(replaceKeepingLines(comment.value, CODE_SPAN, "``"))) {
-    return wholeComment("code", "legal comment");
+  const value = comment.doc ? comment.value.slice(1) : comment.value.replace(/^\*/, "");
+  if (isLegal(comment.value, language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
   }
-  if (LINE_DIRECTIVE.test(value) || BLOCK_DIRECTIVE.test(value)) {
-    return wholeComment("code", "directive");
+  if (LINE_DIRECTIVE.test(value) || language.blockDirective?.test(value)) {
+    return wholeComment(shape, lines, "code", "directive");
   }
   const other = () => {
     return wholeComment(
+      shape,
+      lines,
       "other",
       startLine === endLine ? "single-line block comment" : "unsupported block comment layout"
     );
   };
-  if (startLine === endLine || !/^\s*\/\*\*?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
+  if (startLine === endLine || !/^\s*\/\*[*!]?$/.test(lines[0]) || !/^\s*\*\/$/.test(lines.at(-1) ?? "")) {
     return other();
   }
   const body = [];
@@ -1259,7 +1483,52 @@ function shapeBlock(comment, sourceLines, lineStarts) {
       hardBreak: HARD_BREAK.test(text)
     });
   }
-  return { kind, startLine, endLine, paragraphs: segment(body) };
+  return { ...shape, paragraphs: segment(body, language) };
+}
+function shapeLineRun(group, sourceLines, lineStarts, language) {
+  const startLine = lineOf(lineStarts, group[0].start);
+  const endLine = startLine + group.length - 1;
+  const kind = group[0].doc === "inner" ? "inner-line-doc" : "outer-line-doc";
+  const shape = { kind, startLine, endLine };
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  const values = group.map((comment) => comment.value.slice(1));
+  if (isLegal(values.join("\n"), language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
+  }
+  if (LINE_DIRECTIVE.test(values[0])) {
+    return wholeComment(shape, lines, "code", "directive");
+  }
+  const body = lines.map((line, offset) => {
+    const [, marker, space, text] = /^(\s*\/\/[/!])( ?)(.*)$/.exec(line) ?? ["", "", "", line];
+    return {
+      index: startLine + offset,
+      prefix: `${marker} `,
+      text: text.trimEnd(),
+      verbatim: !space && text.length > 0 || LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    };
+  });
+  return { ...shape, paragraphs: segment(body, language) };
+}
+function shapeLineComment(group, sourceLines, lineStarts, language) {
+  const startLine = lineOf(lineStarts, group[0].start);
+  const endLine = startLine + group.length - 1;
+  const shape = { kind: "line", startLine, endLine };
+  const lines = sourceLines.slice(startLine, endLine + 1);
+  if (isLegal(group.map((comment) => comment.value).join("\n"), language)) {
+    return wholeComment(shape, lines, "code", "legal comment");
+  }
+  const body = lines.map((line, offset) => {
+    const [, marker, space, text] = /^(\s*\/\/[/!]*)( ?)(.*)$/.exec(line) ?? ["", "", "", line];
+    return {
+      index: startLine + offset,
+      prefix: `${marker}${space}`,
+      text: text.trimEnd(),
+      verbatim: LINE_DIRECTIVE.test(text),
+      hardBreak: HARD_BREAK.test(text)
+    };
+  });
+  return { ...shape, paragraphs: segment(body, { ...language, tags: false }) };
 }
 function ownsLines(comment, source, lineStarts) {
   const startLine = lineOf(lineStarts, comment.start);
@@ -1269,12 +1538,12 @@ function ownsLines(comment, source, lineStarts) {
   const after = source.slice(comment.end, lineEnd);
   return /^[\t ]*$/.test(before) && /^[\t ]*\r?\n?$/.test(after);
 }
-function singleLineLength(paragraph, options) {
+function singleLineLength(paragraph, options, language) {
   const [first] = paragraph.lines;
   if (paragraph.kind === "other" && paragraph.reason === "single-line block comment") {
     return sourceLineLength(first, options.tabWidth);
   }
-  if (paragraph.kind !== "prose" || structureOf(paragraph.lines)) {
+  if (paragraph.kind !== "prose" || structureOf(paragraph.lines, language)) {
     return Infinity;
   }
   const text = tokenize(paragraph.lines.map((line) => line.text).join(" ")).join(" ");
@@ -1289,6 +1558,58 @@ function describeFailure(errors, lineStarts) {
   const offset = first.labels.at(0)?.start;
   return { message: first.message, line: offset === void 0 ? void 0 : lineOf(lineStarts, offset) + 1 };
 }
+function scanJavaScript(filename, text, lineStarts) {
+  const { program, comments, errors } = parseSource(filename, text);
+  if (errors.length > 0 && program.body.length === 0) {
+    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  }
+  return {
+    comments: comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")))
+  };
+}
+function scanRustSource(text, lineStarts) {
+  const { comments, error } = scanRust(text);
+  if (error) {
+    return { comments: [], syntaxError: { message: error.message, line: lineOf(lineStarts, error.offset) + 1 } };
+  }
+  return {
+    comments: comments.map((comment) => {
+      return {
+        type: comment.block ? "Block" : "Line",
+        value: text.slice(comment.start + 2, comment.block ? comment.end - 2 : comment.end),
+        start: comment.start,
+        end: comment.end,
+        doc: comment.doc
+      };
+    })
+  };
+}
+function groupLineRuns(comments, text, lineStarts, markerOf) {
+  const groups = [];
+  let current;
+  let previousLine = -1;
+  let indent = "";
+  let marker;
+  for (const comment of comments) {
+    const next = comment.type === "Line" ? markerOf(comment) : void 0;
+    if (next === void 0 || !ownsLines(comment, text, lineStarts)) {
+      current = void 0;
+      continue;
+    }
+    const line = lineOf(lineStarts, comment.start);
+    const before = text.slice(lineStarts[line], comment.start);
+    if (current && line === previousLine + 1 && next === marker && before === indent) {
+      current.push(comment);
+    } else {
+      current = [comment];
+      indent = before;
+      marker = next;
+      groups.push(current);
+    }
+    previousLine = line;
+  }
+  return groups;
+}
 function analyzeSource(source, filename, options) {
   return inspectSource(source, filename, options).comments;
 }
@@ -1297,28 +1618,16 @@ function inspectSource(source, filename, options) {
     throw new Error("comments: maxWidth must be an integer at least as large as width");
   }
   const text = source.startsWith(BYTE_ORDER_MARK) ? source.slice(1) : source;
-  const { program, comments, errors } = parseSource(filename, text);
+  const language = languageOf(filename);
   const lineStarts = computeLineStarts(text);
-  if (errors.length > 0 && program.body.length === 0) {
-    return { comments: [], syntaxError: describeFailure(errors, lineStarts) };
+  const scanned = language.name === "rust" ? scanRustSource(text, lineStarts) : scanJavaScript(filename, text, lineStarts);
+  if (scanned.syntaxError) {
+    return { comments: [], syntaxError: scanned.syntaxError };
   }
   const sourceLines = text.split("\n").map((line) => stripCarriageReturn(line));
-  const parsed = comments.filter((comment) => !(comment.start === 0 && text.startsWith("#!")));
   const reports = [];
-  const blocks = parsed.filter((comment) => {
-    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
-  });
-  for (const block of blocks) {
-    const shape = shapeBlock(block, sourceLines, lineStarts);
-    const singleLineWidth = Math.max(
-      options.width,
-      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
-    );
-    const singleLineLimit = Math.min(singleLineWidth + options.tolerance, options.maxWidth ?? Infinity);
-    const singleLine = shape.paragraphs.length === 1 ? singleLineLength(shape.paragraphs[0], options) : Infinity;
-    const paragraphOptions = singleLine <= singleLineLimit ? { ...options, width: Math.max(singleLineWidth, singleLine) } : options;
-    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
-    reports.push({
+  const report = (shape, lines, paragraphs) => {
+    return {
       file: filename,
       kind: shape.kind,
       startLine: shape.startLine + 1,
@@ -1328,8 +1637,47 @@ function inspectSource(source, filename, options) {
       maxWidth: options.maxWidth,
       lengths: lines.map((line) => visualLength(line.trimEnd(), options.tabWidth)),
       text: lines.join("\n"),
-      paragraphs: shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions))
+      paragraphs
+    };
+  };
+  const blocks = scanned.comments.filter((comment) => {
+    return comment.type === "Block" && ownsLines(comment, text, lineStarts) && !comment.value.includes(IGNORE_DIRECTIVE);
+  });
+  const runs = (markerOf) => {
+    return groupLineRuns(scanned.comments, text, lineStarts, markerOf).filter((group) => {
+      return !group.some((comment) => comment.value.includes(IGNORE_DIRECTIVE));
     });
+  };
+  const shapes = [
+    ...blocks.map((block) => shapeBlock(block, sourceLines, lineStarts, language)),
+    ...runs((comment) => comment.doc).map((group) => shapeLineRun(group, sourceLines, lineStarts, language)),
+    ...runs((comment) => comment.doc ? void 0 : "//").map(
+      (group) => shapeLineComment(group, sourceLines, lineStarts, language)
+    )
+  ].toSorted((a, b) => a.startLine - b.startLine);
+  for (const shape of shapes) {
+    const lines = sourceLines.slice(shape.startLine, shape.endLine + 1);
+    if (shape.kind === "line") {
+      const paragraphs = shape.paragraphs.map((paragraph) => analyzeLineParagraph(paragraph, options, language));
+      if (paragraphs.some((paragraph) => paragraph.issues.length > 0)) {
+        reports.push(report(shape, lines, paragraphs));
+      }
+      continue;
+    }
+    const singleLineWidth = Math.max(
+      options.width,
+      Math.min(options.singleLineWidth ?? options.width, options.maxWidth ?? Infinity)
+    );
+    const singleLineLimit = Math.min(singleLineWidth + options.tolerance, options.maxWidth ?? Infinity);
+    const singleLine = shape.paragraphs.length === 1 ? singleLineLength(shape.paragraphs[0], options, language) : Infinity;
+    const paragraphOptions = singleLine <= singleLineLimit ? { ...options, width: Math.max(singleLineWidth, singleLine) } : options;
+    reports.push(
+      report(
+        shape,
+        lines,
+        shape.paragraphs.map((paragraph) => analyzeParagraph(paragraph, paragraphOptions, language))
+      )
+    );
   }
   return { comments: reports };
 }
@@ -1350,6 +1698,9 @@ function rewrapComment(report) {
 }
 var POSITION_KEYS = /* @__PURE__ */ new Set(["start", "end", "range", "loc"]);
 function codeFingerprint(source, filename) {
+  if (languageOf(filename).name === "rust") {
+    return rustFingerprint(source);
+  }
   const { program, errors } = parseSource(filename, source);
   if (errors.length > 0) {
     return JSON.stringify({ source, errors: errors.map((error) => error.message) });
@@ -1363,7 +1714,7 @@ function codeFingerprint(source, filename) {
 // src/comments/agent.ts
 import { spawn } from "child_process";
 import { readFileSync } from "fs";
-import path from "path";
+import path2 from "path";
 var DEFAULT_RULES = `
 # Comment rules
 
@@ -1371,7 +1722,7 @@ var DEFAULT_RULES = `
 
 When rules pull in different directions, the earlier one wins.
 
-1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, and notation like \`host:port\`.
+1. Keep code and exact text byte for byte, including every punctuation character in it. That covers code blocks, \`@example\`, code spans, identifiers, string literals like error messages, regexes, globs and other patterns like \`*test*\`, URLs, quoted text, titles, notation like \`host:port\`, and Rust intra-doc links (see below).
 2. Keep the meaning. An edit may make a comment clearer, never different.
 3. Follow the style preferences below.
 4. Change as little as possible. Wording that already reads clearly stays, even when a note points at it.
@@ -1384,10 +1735,12 @@ When rules pull in different directions, the earlier one wins.
 - A comment whose whole text is one paragraph stays on a single line when that line fits a separate, larger single-line width, even past the width. Only a longer comment wraps to the width.
 - Separate paragraphs with an empty comment line.
 - Never split a backtick code span across lines.
+- Never split a Markdown link across lines. A link is the text in brackets and the target right after it, like \`[the docs](https://example.com)\`, \`[the docs][label]\`, or \`[the docs]\`, and all of it stays on one line, from its first bracket to its last bracket or parenthesis. An editor can't follow a link that continues on the next line. When a line is too long, break it before or after the link.
 - Keep code blocks, \`@example\`, lists, tables, box drawings, aligned columns, and Markdown hard line breaks (a line that ends with two spaces or a backslash) laid out as they are. List items wrap with their continuation lines indented to the item text, and a JSDoc tag description that doesn't fit continues on the next line without indentation.
 - The tool measures every line, taking the tolerance and the parts it keeps as written into account, and the notes on each comment list what is still wrong. Act on those notes. Don't count columns, and don't apply a stricter limit than the notes show.
 - The maximum is a hard limit for measured prose, including long tokens. If a URL, code span, or other exact text exceeds it, preserve that text and explain the unresolved overflow instead of changing its contents.
 - The tool never rewraps the parts it keeps as written, like a single-line block comment, a paragraph with hard line breaks, or lines that may be laid out by hand. When a note says one of their prose lines is too long, break or shorten it yourself. Exact text and intentional layout win over the width, so keep code, code spans, and the layout in them intact, and if a note can only be fixed by changing them, leave it and say why in your reply.
+- The tool never rewraps a line comment (\`//\`) either. When a note says one of its lines is too long, shorten the wording so the comment fits on its line and still says the same thing. When it can't be shortened without losing meaning, turn it into a multi-line block comment instead: \`/**\` in JavaScript and TypeScript, or \`/*\` in Rust, on its own line, then the text on lines that start with \` * \`, then \` */\` on its own line, all at the indentation of the line comment. Like other block comments, it starts with a capital letter and ends with punctuation. Leave its line breaks to the tool, which rewraps it like any other block comment. Never split a line comment into more \`//\` lines.
 
 ## Style
 
@@ -1398,8 +1751,16 @@ These are preferences for comment prose. They never apply to code or exact text
 - Prefer a sentence over a "Label: explanation" fragment, like \`...the socket. Optional: without it...\` or \`Default: refuse\` in the middle of prose. A colon is fine where it introduces a list, code block, or example, in a term's definition, in notation, in a quotation, and in a \`Note:\` or \`Optional:\` that starts a comment. A JSDoc tag like \`@note\` or \`@todo\` can replace a label, and \`@default\` fits a default value, not a description.
 - Avoid asterisk emphasis like \`*this*\`, and use plain wording instead. A name or pattern in asterisks, like \`*test*\` or \`*.spec.ts\`, is a pattern, so keep its asterisks and wrap it in a code span, like \`\` \`*test*\` \`\`.
 - Avoid section banner comments, i.e. dividers or headings made of dashes, equals signs, asterisks, or other repeated characters that split a file into visual sections. Let the code structure carry the grouping, or write one short, plain sentence comment (e.g. \`// handlers for control mode\`). Rules that belong to a diagram, a table, a box drawing, a Markdown document, an example, or a legal header aren't banners.
-- Block and JSDoc comments are capitalized and end with punctuation.
-- Never turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines.
+- Block, JSDoc, and Rust doc comments are capitalized and end with punctuation.
+- Never change the kind of a comment, except to turn a line comment that is too long into a block comment (see Layout). Don't turn a block or JSDoc comment into \`//\` line comments, and never write a run of consecutive \`//\` lines. In Rust, a run of \`///\` or \`//!\` lines is one doc comment, so keep its markers, and never turn a doc comment (\`///\`, \`//!\`, \`/**\`, \`/*!\`) into another kind, since that changes or removes documentation.
+
+## Rust doc comments
+
+Rust doc comments are Markdown that rustdoc renders.
+
+- Intra-doc links are exact text. Keep their brackets, backticks, and targets, like \`\` [\`count_provider_reads\`] \`\`, \`\` [\`permissions\`](crate::permissions) \`\`, \`\` [the parser][\`Parser\`] \`\`, or \`[Vec<T>]\`, since rustdoc resolves the text in brackets, or the target after it, as a path. Each link stays on one line (see Layout), including a link with spaces in its text, like \`[the provider module](crate::provider)\`.
+- A link reference definition, like \`\` [\`Foo\`]: crate::Foo \`\`, stays on its own line as it is. Its colon is syntax, not a label.
+- Headings like \`# Examples\`, \`# Panics\`, \`# Errors\`, and \`# Safety\` are sections that rustdoc and readers look for, so keep them. Code blocks are doctests, so keep their lines, including hidden lines that start with \`#\`, exactly as they are.
 
 ## Editing
 
@@ -1408,11 +1769,11 @@ These are preferences for comment prose. They never apply to code or exact text
 `.trim();
 
 // src/comments/config.ts
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { createRequire } from "module";
-import path2 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import path3 from "path";
 import { pathToFileURL } from "url";
-var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts"]);
+var DEFAULT_EXTENSIONS = Object.freeze([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx", ".mts", ".cts", ".rs"]);
 var CONFIG_FILES = [
   "comments.config.ts",
   "comments.config.mts",
@@ -1463,10 +1824,12 @@ function validateConfig(raw, filepath) {
   assertType(config.avoidSentenceOrphans, "boolean", "avoidSentenceOrphans", filepath);
   assertType(config.style, "boolean", "style", filepath);
   assertType(config.extensions, "array", "extensions", filepath);
+  assertType(config.include, "array", "include", filepath);
   assertType(config.ignore, "array", "ignore", filepath);
   assertType(config.agent, "object", "agent", filepath);
   assertType(config.hook, "object", "hook", filepath);
   assertStrings(config.extensions, "extensions", filepath);
+  assertStrings(config.include, "include", filepath);
   assertStrings(config.ignore, "ignore", filepath);
   for (const key of ["width", "maxWidth", "singleLineWidth", "tolerance"]) {
     const value = config[key];
@@ -1499,8 +1862,8 @@ function validateConfig(raw, filepath) {
   }
   assertType(agent.rules, "string", "agent.rules", filepath);
   assertType(agent.instructions, "string", "agent.instructions", filepath);
-  if (agent.scope !== void 0 && agent.scope !== "suspicious" && agent.scope !== "all") {
-    throw new Error(`comments: \`agent.scope\` in ${filepath} must be "suspicious" or "all"`);
+  if (agent.scope !== void 0 && !["suspicious", "failing", "all"].includes(agent.scope)) {
+    throw new Error(`comments: \`agent.scope\` in ${filepath} must be one of suspicious, failing, all`);
   }
   const hook = config.hook ?? {};
   if (hook.mode !== void 0 && !["agent", "report", "off"].includes(hook.mode)) {
@@ -1510,25 +1873,25 @@ function validateConfig(raw, filepath) {
 }
 async function loadConfig(cwd, options = {}) {
   if (options.explicitPath) {
-    const filepath = path2.resolve(cwd, options.explicitPath);
+    const filepath = path3.resolve(cwd, options.explicitPath);
     return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
   }
-  let directory = path2.resolve(cwd);
+  let directory = path3.resolve(cwd);
   for (; ; ) {
     for (const name of CONFIG_FILES) {
-      const filepath = path2.join(directory, name);
-      if (existsSync(filepath)) {
+      const filepath = path3.join(directory, name);
+      if (existsSync2(filepath)) {
         return { config: validateConfig(await readConfigFile(filepath), filepath), filepath };
       }
     }
-    const packageJsonPath = path2.join(directory, "package.json");
-    if (existsSync(packageJsonPath)) {
+    const packageJsonPath = path3.join(directory, "package.json");
+    if (existsSync2(packageJsonPath)) {
       const value = readJson(packageJsonPath)[PACKAGE_JSON_KEY];
       if (value !== void 0) {
         return { config: validateConfig(value, packageJsonPath), filepath: packageJsonPath };
       }
     }
-    const parent = path2.dirname(directory);
+    const parent = path3.dirname(directory);
     if (directory === options.stopDir || parent === directory) {
       return { config: {} };
     }