@tony.ganchev/eslint-plugin-header 3.2.0 → 3.2.1

package/lib/rules/header.js

@@ -24,9 +24,9 @@
 
 "use strict";
 
-const assert = require("assert");
-const fs = require("fs");
-const os = require("os");
+const assert = require("node:assert");
+const fs = require("node:fs");
+const os = require("node:os");
 const commentParser = require("../comment-parser");
 const { contextSourceCode } = require("./eslint-utils");
 const { description, recommended, url } = require("./header.docs");
@@ -38,8 +38,6 @@ const { lineEndingOptions, commentTypeOptions, schema } = require("./header.sche
  * @typedef {import('eslint').Rule.NodeListener} NodeListener
  * @typedef {import('eslint').Rule.ReportFixer} ReportFixer
  * @typedef {import('eslint').Rule.RuleFixer} RuleFixer
- * @typedef {import('eslint').Rule.RuleTextEdit} RuleTextEdit
- * @typedef {import('eslint').Rule.RuleTextEditor} RuleTextEditor
  * @typedef {import('eslint').Rule.RuleContext} RuleContext
  * @typedef {import('estree').Comment} Comment
  * @typedef {import('estree').Program} Program
@@ -50,61 +48,67 @@ const { lineEndingOptions, commentTypeOptions, schema } = require("./header.sche
  * Local type definitions.
  * @typedef {{ pattern: string | RegExp, template?: string }} HeaderLinePattern
  * @typedef {string | RegExp | HeaderLinePattern} HeaderLine
- * @typedef {(HeaderLine | HeaderLine[])} HeaderLines
- * @typedef {{ lineEndings?: ('unix' | 'windows' | 'os') }} HeaderSettings
- * @typedef {
- *  [string]
- *  | [string, HeaderSettings]
- *  | [('block' | 'line'), HeaderLines ]
- *  | [('block' | 'line'), HeaderLines, HeaderSettings]
- *  | [('block' | 'line'), HeaderLines, number ]
- *  | [('block' | 'line'), HeaderLines, number, HeaderSettings]
- * } LegacyHeaderOptions
- * @typedef {
- *  {
+ * @typedef {HeaderLine | HeaderLine[]} HeaderLines
+ * @typedef {'os' | 'unix' | 'windows'} LineEndingOption
+ * @typedef {{ lineEndings?: LineEndingOption }} HeaderSettings
+ * @typedef {'block' | 'line'} CommentType
+ * @typedef {{
  *      file: string,
- *      encoding?: string
+ *      encoding?: BufferEncoding
  *  }
  * } FileBasedConfig
- * @typedef {
- *  {
- *      commentType: 'line' | 'block',
+ * @typedef {{
+ *      commentType: CommentType,
  *      lines: HeaderLine[]
  *  }
- * } LinesBasedConfig
+ * } InlineConfig
  * @typedef {{ minimum?: number }} TrailingEmptyLines
- * @typedef {
- *  {
- *      header: FileBasedConfig | LinesBasedConfig,
+ * @typedef {{
+ *      header: FileBasedConfig | InlineConfig,
  *      trailingEmptyLines?: TrailingEmptyLines
  *  }
  *  & HeaderSettings
- * } NewHeaderOptions
- * @typedef {LegacyHeaderOptions | [NewHeaderOptions]} HeaderOptions
+ * } HeaderOptions
+ * @typedef {[HeaderOptions] |
+ *  [template: string] |
+ *  [template: string, settings: HeaderSettings] |
+ *  [type: CommentType, lines: HeaderLines] |
+ *  [type: CommentType, lines: HeaderLines, settings: HeaderSettings] |
+ *  [type: CommentType, lines: HeaderLines, minLines: number] |
+ *  [
+ *     type: CommentType,
+ *     lines: HeaderLines,
+ *     minLines: number,
+ *     settings: HeaderSettings
+ *  ]
+ * } AllHeaderOptions
+ * @typedef {import('eslint').Linter.RuleEntry<AllHeaderOptions>
+ * } HeaderRuleConfig
  */
 
 /**
  * Tests if the passed line configuration string or object is a pattern
  * definition.
  * @param {HeaderLine} object line configuration object or string
- * @returns {boolean} `true` if the line configuration is a pattern-defining
- *                    object or `false` otherwise.
+ * @returns {object is HeaderLinePattern} `true` if the line configuration is a
+ *                                        pattern-defining object or `false`
+ *                                        otherwise.
  */
 function isPattern(object) {
     return typeof object === "object"
-        && (object instanceof RegExp || Object.prototype.hasOwnProperty.call(object, "pattern"));
+        && (Object.prototype.hasOwnProperty.call(object, "pattern"));
 }
 
 /**
  * Utility over a line config argument to match an expected string either
  * against a regex or for full match against a string.
- * @param {HeaderLine} actual the string to test.
- * @param {string} expected The string or regex to test again.
+ * @param {string} actual the string to test.
+ * @param {string | RegExp} expected The string or regex to test again.
  * @returns {boolean} `true` if the passed string matches the expected line
  *                    config or `false` otherwise.
  */
 function match(actual, expected) {
-    if (expected.test) {
+    if (expected instanceof RegExp) {
         return expected.test(actual);
     } else {
         return expected === actual;
@@ -113,35 +117,62 @@ function match(actual, expected) {
 
 /**
  * Remove Unix she-bangs from the list of comments.
- * @param {Comment[]} comments the list of comment lines.
+ * @param {(Comment | { type: "Shebang" })[]} comments the list of comment
+ *                                                     lines.
  * @returns {Comment[]} the list of comments with containing all incoming
  *                      comments from `comments` with the shebang comments
  *                      omitted.
  */
 function excludeShebangs(comments) {
+    /** @type {Comment[]} */
     return comments.filter(function(comment) {
         return comment.type !== "Shebang";
     });
 }
 
+/**
+ * TypeScript helper to confirm defined type.
+ * @template T
+ * @param {T | undefined} val  the value to validate.
+ * @returns {asserts val is T} validates defined type
+ */
+function assertDefined(val) {
+    assert.strict.notEqual(typeof val, "undefined");
+}
+
+/**
+ * TypeScript helper to confirm non-null type.
+ * @template T
+ * @param {T | null} val  the value to validate.
+ * @returns {asserts val is T} validates non-null type
+ */
+function assertNotNull(val) {
+    assert.strict.notEqual(val, null);
+}
+
 /**
  * Returns either the first block comment or the first set of line comments that
  * are ONLY separated by a single newline. Note that this does not actually
  * check if they are at the start of the file since that is already checked by
  * `hasHeader()`.
  * @param {RuleContext} context ESLint execution environment.
- * @param {Program} node ESLint AST tree node being processed.
  * @returns {Comment[]} lines that constitute the leading comment.
  */
-function getLeadingComments(context, node) {
+function getLeadingComments(context) {
     const sourceCode = contextSourceCode(context);
-    const all = excludeShebangs(sourceCode.getAllComments(node.body.length ? node.body[0] : node));
+    const all = excludeShebangs(sourceCode.getAllComments());
+    assert.ok(all);
+    assert.ok(all.length);
     if (all[0].type.toLowerCase() === commentTypeOptions.block) {
         return [all[0]];
     }
     let i = 1;
     for (; i < all.length; ++i) {
-        const txt = sourceCode.text.slice(all[i - 1].range[1], all[i].range[0]);
+        const previousRange = all[i - 1].range;
+        assertDefined(previousRange);
+        const currentRange = all[i].range;
+        assertDefined(currentRange);
+        const txt = sourceCode.text.slice(previousRange[1], currentRange[0]);
         if (!txt.match(/^(\r\n|\r|\n)$/)) {
             break;
         }
@@ -152,7 +183,7 @@ function getLeadingComments(context, node) {
 /**
  * Generate a comment including trailing spaces out of a number of comment body
  * lines.
- * @param {'block' | 'line'} commentType the type of comment to generate.
+ * @param {CommentType} commentType the type of comment to generate.
  * @param {string[]} textArray list of lines of the comment content.
  * @param {'\n' | '\r\n'} eol end-of-line characters.
  * @returns {string} resulting comment.
@@ -170,12 +201,21 @@ function genCommentBody(commentType, textArray, eol) {
 /**
  * Determines the start and end position in the source code of the leading
  * comment.
- * @param {string[]} comments list of comments.
+ * @param {Comment[]} comments list of comments.
  * @returns {[number, number]} resulting range.
  */
 function genCommentsRange(comments) {
-    const start = comments[0].range[0];
-    const end = comments.slice(-1)[0].range[1];
+    assert.ok(comments.length);
+    const firstComment = comments[0];
+    assertDefined(firstComment);
+    const firstCommentRange = firstComment.range;
+    assertDefined(firstCommentRange);
+    const start = firstCommentRange[0];
+    const lastComment = comments.slice(-1)[0];
+    assertDefined(lastComment);
+    const lastCommentRange = lastComment.range;
+    assertDefined(lastCommentRange);
+    const end = lastCommentRange[1];
     return [start, end];
 }
 
@@ -201,7 +241,7 @@ function leadingEmptyLines(src) {
 
 /**
  * Factory for fixer that adds a missing header.
- * @param {'block' | 'line'} commentType type of comment to use.
+ * @param {CommentType} commentType type of comment to use.
  * @param {RuleContext} context ESLint execution runtime.
  * @param {string[]} headerLines lines of the header comment.
  * @param {'\n' | '\r\n'} eol end-of-line characters
@@ -232,15 +272,13 @@ function genPrependFixer(commentType, context, headerLines, eol, numNewlines) {
 
 /**
  * Factory for fixer that replaces an incorrect header.
- * @param {'block' | 'line'} commentType type of comment to use.
+ * @param {CommentType} commentType type of comment to use.
  * @param {RuleContext} context ESLint execution context.
  * @param {Comment[]} leadingComments comment elements to replace.
  * @param {string[]} headerLines lines of the header comment.
  * @param {'\n' | '\r\n'} eol end-of-line characters
  * @param {number} numNewlines number of trailing lines after the comment.
- * @returns {
- *  (fixer: RuleTextEditor) => RuleTextEdit | RuleTextEdit[] | null
- * } the fixer.
+ * @returns {(fixer: RuleFixer) => Fix | Fix[] | null} the fixer.
  */
 function genReplaceFixer(commentType, context, leadingComments, headerLines, eol, numNewlines) {
     return function(fixer) {
@@ -250,7 +288,7 @@ function genReplaceFixer(commentType, context, leadingComments, headerLines, eol
         const eols = eol.repeat(missingNewlines);
         return fixer.replaceTextRange(
             commentRange,
-            genCommentBody(commentType, headerLines, eol, numNewlines) + eols
+            genCommentBody(commentType, headerLines, eol) + eols
         );
     };
 }
@@ -261,9 +299,7 @@ function genReplaceFixer(commentType, context, leadingComments, headerLines, eol
  * @param {'\n' | '\r\n'} eol end-of-line characters
  * @param {number} missingEmptyLinesCount number of trailing lines after the
  *                                        comment.
- * @returns {
- *  (fixer: RuleTextEditor) => RuleTextEdit | RuleTextEdit[] | null
- * } the fixer.
+ * @returns {(fixer: RuleFixer) => Fix | Fix[] | null} the fixer.
  */
 function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
     return function(fixer) {
@@ -277,7 +313,7 @@ function genEmptyLinesFixer(leadingComments, eol, missingEmptyLinesCount) {
 /**
  * Returns the used line-termination characters per the rule's config if any or
  * else based on the runtime environments.
- * @param {'os' | 'unix' | 'windows'} style line-ending styles.
+ * @param {LineEndingOption} style line-ending styles.
  * @returns {'\n' | '\r\n'} the correct line ending characters for the
  *                          environment.
  */
@@ -291,7 +327,7 @@ function getEol(style) {
             return "\r\n";
         case lineEndingOptions.os:
         default:
-            return os.EOL;
+            return /** @type {'\n' | '\r\n'} */ (os.EOL);
     }
 }
 
@@ -323,8 +359,9 @@ function schemaAssert(condition, message) {
  * options in that some settings are still union types and unspecified
  * properties are not replaced by defaults. If the options follow the new
  * format, a simple seep copy would be returned.
- * @param {HeaderOptions} originalOptions the options as configured by the user.
- * @returns {NewHeaderOptions} the transformed new-style options with no
+ * @param {AllHeaderOptions} originalOptions the options as configured by the
+ *                                           user.
+ * @returns {HeaderOptions} the transformed new-style options with no
  *                             normalization.
  */
 function transformLegacyOptions(originalOptions) {
@@ -342,7 +379,7 @@ function transformLegacyOptions(originalOptions) {
     // config.
     schemaAssert(typeof originalOptions[0] === "string",
         "first header option after severity should be either a filename or 'block' | 'line'");
-    /** @type {NewHeaderOptions} */
+    /** @type {HeaderOptions} */
     const transformedOptions = {};
     // populate header
     if (
@@ -351,7 +388,7 @@ function transformLegacyOptions(originalOptions) {
             originalOptions.length === 2
             && typeof originalOptions[1] === "object"
             && !Array.isArray(originalOptions[1])
-            && !isPattern(originalOptions[1])
+            && !isPattern(/** @type {HeaderLine} */(originalOptions[1]))
         )) {
         transformedOptions.header = { file: originalOptions[0], encoding: "utf8" };
     } else {
@@ -360,11 +397,14 @@ function transformLegacyOptions(originalOptions) {
         schemaAssert(
             typeof originalOptions[1] === "string"
             || Array.isArray(originalOptions[1])
-            || isPattern(originalOptions[1]),
+            || isPattern(/** @type {HeaderLine} */(originalOptions[1])),
             "second header option after severity should be a string, a pattern, or an array of the previous two");
         transformedOptions.header = {
-            commentType: originalOptions[0],
-            lines: Array.isArray(originalOptions[1]) ? originalOptions[1] : [originalOptions[1]]
+            commentType: /** @type {CommentType} */ (originalOptions[0]),
+            lines: /** @type {HeaderLine[]} */ (
+                Array.isArray(originalOptions[1])
+                    ? originalOptions[1]
+                    : [originalOptions[1]])
         };
     }
     // configure required line settings
@@ -387,25 +427,42 @@ function transformLegacyOptions(originalOptions) {
     return transformedOptions;
 }
 
+/**
+ * @param {FileBasedConfig | InlineConfig} config the header configuration.
+ * @returns {config is FileBasedConfig} true if `config` is `FileBasedConfig`.
+ */
+function isFileBasedHeaderConfig(config) {
+    return Object.prototype.hasOwnProperty.call(config, "file");
+}
+
+/**
+ * @param {FileBasedConfig | InlineConfig} config the header configuration.
+ * @returns {asserts config is InlineConfig} asserts `config` is
+ *                                               `LineBasedConfig`.
+ */
+function assertLineBasedHeaderConfig(config) {
+    assert.ok(Object.prototype.hasOwnProperty.call(config, "lines"));
+}
+
 /**
  * Transforms a set of new-style options adding defaults and standardizing on
  * one of multiple config styles.
- * @param {NewHeaderOptions} originalOptions new-style options to normalize.
- * @returns {NewHeaderOptions} normalized options.
+ * @param {HeaderOptions} originalOptions new-style options to normalize.
+ * @returns {HeaderOptions} normalized options.
  */
 function normalizeOptions(originalOptions) {
     const options = structuredClone(originalOptions);
 
-    if (options.header.file) {
+    if (isFileBasedHeaderConfig(originalOptions.header)) {
         const text = fs.readFileSync(originalOptions.header.file, originalOptions.header.encoding || "utf8");
         const [commentType, lines] = commentParser(text);
         options.header = { commentType, lines };
     }
-
+    assertLineBasedHeaderConfig(options.header);
     options.header.lines = options.header.lines.flatMap(
         (line) => {
             if (typeof line === "string") {
-                return line.split(/\r?\n/);
+                return /** @type {HeaderLine[]} */(line.split(/\r?\n/));
             }
             if (line instanceof RegExp) {
                 return [{ pattern: line }];
@@ -448,7 +505,11 @@ function normalizeOptions(originalOptions) {
  * @returns {SourceLocation} the location (line and column) of the violation.
  */
 function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
-    const lastCommentLineLocEnd = leadingComments[leadingComments.length - 1].loc.end;
+    assert.ok(leadingComments);
+    const loc = leadingComments[leadingComments.length - 1].loc;
+    assertDefined(loc);
+    assertNotNull(loc);
+    const lastCommentLineLocEnd = loc.end;
     return {
         start: lastCommentLineLocEnd,
         end: {
@@ -458,7 +519,8 @@ function missingEmptyLinesViolationLoc(leadingComments, actualEmptyLines) {
     };
 }
 
-module.exports = {
+/** @type {import('eslint').Rule.RuleModule} */
+const headerRule = {
     meta: {
         type: "layout",
         docs: {
@@ -469,7 +531,7 @@ module.exports = {
         fixable: "whitespace",
         schema,
         defaultOptions: [
-            /** @type {HeaderOptions} */
+            /** @type {AllHeaderOptions} */
             {
                 lineEndings: lineEndingOptions.os,
                 trailingEmptyLines: {
@@ -497,34 +559,48 @@ module.exports = {
      */
     create: function(context) {
 
-        const newStyleOptions = transformLegacyOptions(context.options);
+        const newStyleOptions = transformLegacyOptions(/** @type {AllHeaderOptions} */ (context.options));
         const options = normalizeOptions(newStyleOptions);
 
-        const eol = getEol(options.lineEndings);
+        assertLineBasedHeaderConfig(options.header);
+        const commentType = /** @type {CommentType} */ (options.header.commentType);
+
+        const eol = getEol(
+            /** @type {LineEndingOption} */ (options.lineEndings)
+        );
 
+        /** @type {string[]} */
         let fixLines = [];
         // If any of the lines are regular expressions, then we can't
         // automatically fix them. We set this to true below once we
         // ensure none of the lines are of type RegExp
         let canFix = true;
         const headerLines = options.header.lines.map(function(line) {
-            const isRegex = isPattern(line);
             // Can only fix regex option if a template is also provided
-            if (isRegex && !line.template) {
-                canFix = false;
+            if (isPattern(line)) {
+                if (Object.prototype.hasOwnProperty.call(line, "template")) {
+                    fixLines.push(/** @type {string} */ (line.template));
+                } else {
+                    canFix = false;
+                    fixLines.push("");
+                }
+                return line.pattern;
+            } else {
+                fixLines.push(/** @type {string} */ (line));
+                return line;
             }
-            fixLines.push(line.template || line);
-            return isRegex ? line.pattern : line;
         });
 
+
+        const numLines = /** @type {number} */ (options.trailingEmptyLines?.minimum);
+
         return {
             /**
              * Hooks into the processing of the overall script node to do the
              * header validation.
-             * @param {Program} node the whole script node
              * @returns {void}
              */
-            Program: function(node) {
+            Program: function() {
                 const sourceCode = contextSourceCode(context);
                 if (!hasHeader(sourceCode.text)) {
                     const hasShebang = sourceCode.text.startsWith("#!");
@@ -542,60 +618,72 @@ module.exports = {
                         },
                         messageId: "missingHeader",
                         fix: genPrependFixer(
-                            options.header.commentType,
+                            commentType,
                             context,
                             fixLines,
                             eol,
-                            options.trailingEmptyLines.minimum)
+                            numLines)
                     });
                     return;
                 }
-
-                const leadingComments = getLeadingComments(context, node);
-
-                if (leadingComments[0].type.toLowerCase() !== options.header.commentType) {
+                const leadingComments = getLeadingComments(context);
+                const firstLeadingCommentLoc = leadingComments[0].loc;
+                const firstLeadingCommentRange = leadingComments[0].range;
+                assertDefined(firstLeadingCommentRange);
+
+                const lastLeadingCommentLoc = leadingComments[leadingComments.length - 1].loc;
+
+                if (leadingComments[0].type.toLowerCase() !== commentType) {
+                    assertDefined(firstLeadingCommentLoc);
+                    assertNotNull(firstLeadingCommentLoc);
+                    assertDefined(lastLeadingCommentLoc);
+                    assertNotNull(lastLeadingCommentLoc);
                     context.report({
                         loc: {
-                            start: leadingComments[0].loc.start,
-                            end: leadingComments[leadingComments.length - 1].loc.end
+                            start: firstLeadingCommentLoc.start,
+                            end: lastLeadingCommentLoc.end
                         },
                         messageId: "incorrectCommentType",
                         data: {
-                            commentType: options.header.commentType
+                            commentType: commentType
                         },
                         fix: canFix
                             ? genReplaceFixer(
-                                options.header.commentType,
+                                commentType,
                                 context,
                                 leadingComments,
                                 fixLines,
                                 eol,
-                                options.trailingEmptyLines.minimum)
+                                numLines)
                             : null
                     });
                     return;
                 }
-                if (options.header.commentType === commentTypeOptions.line) {
+                if (commentType === commentTypeOptions.line) {
                     if (headerLines.length === 1) {
                         const leadingCommentValues = leadingComments.map((c) => c.value);
                         if (
                             !match(leadingCommentValues.join("\n"), headerLines[0])
                             && !match(leadingCommentValues.join("\r\n"), headerLines[0])
                         ) {
+                            assertDefined(firstLeadingCommentLoc);
+                            assertNotNull(firstLeadingCommentLoc);
+                            assertDefined(lastLeadingCommentLoc);
+                            assertNotNull(lastLeadingCommentLoc);
                             context.report({
                                 loc: {
-                                    start: leadingComments[0].loc.start,
-                                    end: leadingComments[leadingComments.length - 1].loc.end
+                                    start: firstLeadingCommentLoc.start,
+                                    end: lastLeadingCommentLoc.end
                                 },
                                 messageId: "incorrectHeader",
                                 fix: canFix
                                     ? genReplaceFixer(
-                                        options.header.commentType,
+                                        commentType,
                                         context,
                                         leadingComments,
                                         fixLines,
                                         eol,
-                                        options.trailingEmptyLines.minimum)
+                                        numLines)
                                     : null
                             });
                             return;
@@ -603,9 +691,12 @@ module.exports = {
                     } else {
                         for (let i = 0; i < headerLines.length; i++) {
                             if (leadingComments.length - 1 < i) {
+                                assertDefined(lastLeadingCommentLoc);
+                                assertNotNull(lastLeadingCommentLoc);
                                 context.report({
                                     loc: {
-                                        start: leadingComments[leadingComments.length - 1].loc.end
+                                        start: lastLeadingCommentLoc.end,
+                                        end: lastLeadingCommentLoc.end
                                     },
                                     messageId: "headerTooShort",
                                     data: {
@@ -613,40 +704,45 @@ module.exports = {
                                     },
                                     fix: canFix
                                         ? genReplaceFixer(
-                                            options.header.commentType,
+                                            commentType,
                                             context,
                                             leadingComments,
                                             fixLines,
                                             eol,
-                                            options.trailingEmptyLines.minimum)
+                                            numLines)
                                         : null
                                 });
                                 return;
                             }
-                            if (typeof headerLines[i] === "string") {
-                                const leadingCommentLength = leadingComments[i].value.length;
-                                const headerLineLength = headerLines[i].length;
+                            const headerLine = headerLines[i];
+                            const comment = leadingComments[i];
+                            const commentLoc = comment.loc;
+                            assertDefined(commentLoc);
+                            assertNotNull(commentLoc);
+                            if (typeof headerLine === "string") {
+                                const leadingCommentLength = comment.value.length;
+                                const headerLineLength = headerLine.length;
                                 for (let j = 0; j < Math.min(leadingCommentLength, headerLineLength); j++) {
-                                    if (leadingComments[i].value[j] !== headerLines[i][j]) {
+                                    if (comment.value[j] !== headerLine[j]) {
                                         context.report({
                                             loc: {
                                                 start: {
                                                     column: "//".length + j,
-                                                    line: leadingComments[i].loc.start.line
+                                                    line: commentLoc.start.line
                                                 },
-                                                end: leadingComments[i].loc.end
+                                                end: commentLoc.end
                                             },
                                             messageId: "headerLineMismatchAtPos",
                                             data: {
-                                                expected: headerLines[i].substring(j)
+                                                expected: headerLine.substring(j)
                                             },
                                             fix: genReplaceFixer(
-                                                options.header.commentType,
+                                                commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                options.trailingEmptyLines.minimum)
+                                                numLines)
                                         });
                                         return;
                                     }
@@ -654,20 +750,21 @@ module.exports = {
                                 if (leadingCommentLength < headerLineLength) {
                                     context.report({
                                         loc: {
-                                            start: leadingComments[i].loc.end,
+                                            start: commentLoc.end,
+                                            end: commentLoc.end,
                                         },
                                         messageId: "headerLineTooShort",
                                         data: {
-                                            remainder: headerLines[i].substring(leadingCommentLength)
+                                            remainder: headerLine.substring(leadingCommentLength)
                                         },
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                options.header.commentType,
+                                                commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                options.trailingEmptyLines.minimum)
+                                                numLines)
                                             : null
                                     });
                                     return;
@@ -677,45 +774,45 @@ module.exports = {
                                         loc: {
                                             start: {
                                                 column: "//".length + headerLineLength,
-                                                line: leadingComments[i].loc.start.line
+                                                line: commentLoc.start.line
                                             },
-                                            end: leadingComments[i].loc.end,
+                                            end: commentLoc.end,
                                         },
                                         messageId: "headerLineTooLong",
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                options.header.commentType,
+                                                commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                options.trailingEmptyLines.minimum)
+                                                numLines)
                                             : null
                                     });
                                     return;
                                 }
                             } else {
-                                if (!match(leadingComments[i].value, headerLines[i])) {
+                                if (!match(comment.value, headerLine)) {
                                     context.report({
                                         loc: {
                                             start: {
                                                 column: "//".length,
-                                                line: leadingComments[i].loc.start.line,
+                                                line: commentLoc.start.line,
                                             },
-                                            end: leadingComments[i].loc.end,
+                                            end: commentLoc.end,
                                         },
                                         messageId: "incorrectHeaderLine",
                                         data: {
-                                            pattern: headerLines[i]
+                                            pattern: headerLine
                                         },
                                         fix: canFix
                                             ? genReplaceFixer(
-                                                options.header.commentType,
+                                                commentType,
                                                 context,
                                                 leadingComments,
                                                 fixLines,
                                                 eol,
-                                                options.trailingEmptyLines.minimum)
+                                                numLines)
                                             : null
                                     });
                                     return;
@@ -724,15 +821,16 @@ module.exports = {
                         }
                     }
 
-                    const actualLeadingEmptyLines =
-                        leadingEmptyLines(sourceCode.text.substring(leadingComments[headerLines.length - 1].range[1]));
-                    const missingEmptyLines = options.trailingEmptyLines.minimum - actualLeadingEmptyLines;
+                    const commentRange = leadingComments[headerLines.length - 1].range;
+                    assertDefined(commentRange);
+                    const actualLeadingEmptyLines = leadingEmptyLines(sourceCode.text.substring(commentRange[1]));
+                    const missingEmptyLines = numLines - actualLeadingEmptyLines;
                     if (missingEmptyLines > 0) {
                         context.report({
                             loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                             messageId: "noNewlineAfterHeader",
                             data: {
-                                expected: options.trailingEmptyLines.minimum,
+                                expected: numLines,
                                 actual: actualLeadingEmptyLines
                             },
                             fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
@@ -749,8 +847,8 @@ module.exports = {
 
                 /** @type {null | string} */
                 let errorMessageId = null;
-                /** @type {null | Record<string, string | RegExp>} */
-                let errorMessageData = null;
+                /** @type {undefined | Record<string, string | RegExp>} */
+                let errorMessageData;
                 /** @type {null | SourceLocation} */
                 let errorMessageLoc = null;
                 for (let i = 0; i < headerLines.length; i++) {
@@ -761,7 +859,9 @@ module.exports = {
                             if (leadingLine[j] !== headerLine[j]) {
                                 errorMessageId = "headerLineMismatchAtPos";
                                 const columnOffset = i === 0 ? "/*".length : 0;
-                                const line = leadingComments[0].loc.start.line + i;
+                                assertDefined(firstLeadingCommentLoc);
+                                assertNotNull(firstLeadingCommentLoc);
+                                const line = firstLeadingCommentLoc.start.line + i;
                                 errorMessageLoc = {
                                     start: {
                                         column: columnOffset + j,
@@ -784,31 +884,35 @@ module.exports = {
                         if (leadingLine.length < headerLine.length) {
                             errorMessageId = "headerLineTooShort";
                             const startColumn = (i === 0 ? "/*".length : 0) + leadingLine.length;
+                            assertDefined(firstLeadingCommentLoc);
+                            assertNotNull(firstLeadingCommentLoc);
                             errorMessageLoc = {
                                 start: {
                                     column: startColumn,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 },
                                 end: {
                                     column: startColumn + 1,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 }
                             };
                             errorMessageData = {
-                                remainder: headerLines[i].substring(leadingLine.length)
+                                remainder: headerLine.substring(leadingLine.length)
                             };
                             break;
                         }
                         if (leadingLine.length > headerLine.length) {
+                            assertDefined(firstLeadingCommentLoc);
+                            assertNotNull(firstLeadingCommentLoc);
                             errorMessageId = "headerLineTooLong";
                             errorMessageLoc = {
                                 start: {
                                     column: (i === 0 ? "/*".length : 0) + headerLine.length,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 },
                                 end: {
                                     column: (i === 0 ? "/*".length : 0) + leadingLine.length,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 }
                             };
                             break;
@@ -820,14 +924,16 @@ module.exports = {
                                 pattern: headerLine
                             };
                             const columnOffset = i === 0 ? "/*".length : 0;
+                            assertDefined(firstLeadingCommentLoc);
+                            assertNotNull(firstLeadingCommentLoc);
                             errorMessageLoc = {
                                 start: {
                                     column: columnOffset + 0,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 },
                                 end: {
                                     column: columnOffset + leadingLine.length,
-                                    line: leadingComments[0].loc.start.line + i
+                                    line: firstLeadingCommentLoc.start.line + i
                                 }
                             };
                             break;
@@ -837,14 +943,18 @@ module.exports = {
 
                 if (!errorMessageId && leadingLines.length > headerLines.length) {
                     errorMessageId = "headerTooLong";
+                    assertDefined(firstLeadingCommentLoc);
+                    assertNotNull(firstLeadingCommentLoc);
+                    assertDefined(lastLeadingCommentLoc);
+                    assertNotNull(lastLeadingCommentLoc);
                     errorMessageLoc = {
                         start: {
                             column: (headerLines.length === 0 ? "/*".length : 0) + 0,
-                            line: leadingComments[0].loc.start.line + headerLines.length
+                            line: firstLeadingCommentLoc.start.line + headerLines.length
                         },
                         end: {
-                            column: leadingComments[leadingComments.length - 1].loc.end.column - "*/".length,
-                            line: leadingComments[leadingComments.length - 1].loc.end.line
+                            column: lastLeadingCommentLoc.end.column - "*/".length,
+                            line: lastLeadingCommentLoc.end.line
                         }
                     };
                 }
@@ -853,32 +963,33 @@ module.exports = {
                     if (canFix && headerLines.length > 1) {
                         fixLines = [fixLines.join(eol)];
                     }
+                    assertNotNull(errorMessageLoc);
                     context.report({
                         loc: errorMessageLoc,
                         messageId: errorMessageId,
                         data: errorMessageData,
                         fix: canFix
                             ? genReplaceFixer(
-                                options.header.commentType,
+                                commentType,
                                 context,
                                 leadingComments,
                                 fixLines,
                                 eol,
-                                options.trailingEmptyLines.minimum)
+                                numLines)
                             : null
                     });
                     return;
                 }
 
                 const actualLeadingEmptyLines =
-                    leadingEmptyLines(sourceCode.text.substring(leadingComments[0].range[1]));
-                const missingEmptyLines = options.trailingEmptyLines.minimum - actualLeadingEmptyLines;
+                    leadingEmptyLines(sourceCode.text.substring(firstLeadingCommentRange[1]));
+                const missingEmptyLines = numLines - actualLeadingEmptyLines;
                 if (missingEmptyLines > 0) {
                     context.report({
                         loc: missingEmptyLinesViolationLoc(leadingComments, actualLeadingEmptyLines),
                         messageId: "noNewlineAfterHeader",
                         data: {
-                            expected: options.trailingEmptyLines.minimum,
+                            expected: numLines,
                             actual: actualLeadingEmptyLines
                         },
                         fix: genEmptyLinesFixer(leadingComments, eol, missingEmptyLines)
@@ -889,3 +1000,4 @@ module.exports = {
     }
 };
 
+exports.header = headerRule;