@sasjs/lint 2.6.0 → 3.0.0

package/.git-hooks/pre-commit

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# Scan staged changes for secrets before anything else runs.
+# The binary is pinned by the @nogoo9/gitleaks devDependency and lands in
+# node_modules/.bin after `npm i` in the repo root. Commits are blocked until
+# it is installed so no clone silently skips the secrets scan.
+gitleaks_bin=node_modules/.bin/gitleaks
+
+if [ ! -x "$gitleaks_bin" ]; then
+    echo "gitleaks not found - run 'npm i' in the repo root to install it"
+    exit 1
+fi
+
+if ! "$gitleaks_bin" protect --staged --redact; then
+    echo "gitleaks detected a potential secret in your staged changes"
+    echo "Remove the secret, or add a .gitleaksignore entry if it is a false positive"
+    exit 1
+fi

package/.github/CONTRIBUTING.md

@@ -52,3 +52,30 @@ If you are using VS Code for development, you can automatically fix your code to
   ```
 
 If you are using another editor, or are unable to install the extension, you can run `npm run lint:fix` to fix the formatting after you've made your changes.
+
+## Git hooks
+
+The repo ships its own git hooks in [`.git-hooks/`](../.git-hooks):
+
+- `pre-commit` - scans staged changes for secrets with gitleaks, and requires the `@nogoo9/gitleaks` devDependency to be installed
+- `commit-msg` - verifies the commit message follows the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/#summary) standard
+
+The repo `.npmrc` sets `ignore-scripts=true`, so the `prepare` script that would normally set `core.hooksPath` during `npm i` never runs. After cloning (or if your commits are not being checked), activate the hooks with a one-time command, run from the repo root:
+
+```bash
+git config core.hooksPath ./.git-hooks
+```
+
+The pre-commit hook runs the gitleaks binary provided by the `@nogoo9/gitleaks` devDependency, so make sure `npm i` has run in the repo root before your first commit.
+
+If you use the [pre-commit](https://pre-commit.com) framework, the repo also ships a [`.pre-commit-config.yaml`](../.pre-commit-config.yaml) that pins the upstream gitleaks hook to an exact release tag. Activate it with `pre-commit install`.
+
+## CI is the enforcement point
+
+The [build workflow](./workflows/build.yml) scans the full history for secrets with gitleaks, runs `npm audit`, checks code style and runs the tests. The local hooks are convenience - CI is what a red finding must fail.
+
+## The release toolchain lives in the workflow
+
+semantic-release is not a project dependency. Every `@semantic-release` plugin declares a `semantic-release` peer, so adding one to `devDependencies` makes npm auto-install semantic-release along with the `npm` package it bundles - and that bundled npm carries advisories this repo cannot fix.
+
+Instead, [publish.yml](./workflows/publish.yml) installs semantic-release, `@semantic-release/exec` and `@semantic-release/git` on the fly, pinned to exact versions. When you add or remove an entry in `release.plugins` (package.json), update that command to match.

package/.github/workflows/build.yml

@@ -24,18 +24,24 @@ jobs:
           cache: npm
       - name: Install Dependencies
         run: npm ci
+      - name: Scan for secrets (gitleaks)
+        # The local pre-commit hook is suppressed entirely when .npmrc sets
+        # ignore-scripts=true (the prepare script that would activate the
+        # hooks never runs), so CI is the enforcement point: a leaked
+        # credential must fail the build, not just a commit.
+        # Uses the same @nogoo9/gitleaks binary the pre-commit hook pins - the
+        # gitleaks-action requires a license key for organization repos.
+        run: node_modules/.bin/gitleaks detect --source . --redact --no-banner -v
       - name: Security Audit
-        # `npm audit` fails on advisories inside the `npm` package bundled by
-        # @semantic-release/npm, which no overrides entry can reach. The audit
-        # script names those and fails on everything else, so a new advisory
-        # anywhere in the tree still fails the build.
-        run: npm run audit
+        # The release toolchain is not a project dependency (see publish.yml),
+        # so the `npm` package bundled by @semantic-release/npm never reaches
+        # this tree - which is what made the old exemption-based audit script
+        # necessary. A plain audit is clean.
+        run: npm audit
       - name: Check Code Style
         run: npm run lint
       - name: Run Unit Tests
         run: npm test
-      - name: Install rimraf
-        run: npm i -g rimraf
       - name: Build Package
         run: npm run package:lib
         env:

package/.github/workflows/publish.yml

@@ -64,7 +64,18 @@ jobs:
         run: npm run publishInit
 
       - name: Semantic Release
-        run: npx semantic-release
+        # The release toolchain is deliberately not a project dependency: every
+        # @semantic-release plugin declares a `semantic-release` peer, which npm
+        # auto-installs together with the `npm` package semantic-release bundles
+        # - and that bundled npm carries advisories nothing here can fix.
+        # Installing it here, pinned, keeps the dependency tree clean. Keep
+        # these versions in step with `release.plugins` in package.json.
+        run: |
+          npx --yes \
+            --package semantic-release@25.0.9 \
+            --package @semantic-release/exec@7.1.0 \
+            --package @semantic-release/git@11.0.1 \
+            semantic-release
         env:
           GITHUB_TOKEN: ${{ steps.app-token.outputs.token }}   # <-- app token, not secrets.GITHUB_TOKEN
 

package/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+# Hooks for the pre-commit framework - https://pre-commit.com
+#
+# The repo also ships native hooks in .git-hooks/, covering the secret scan, a
+# 2MB commit size limit and Conventional Commits. But .npmrc sets
+# ignore-scripts=true, so the `prepare` script that would activate them never
+# runs on `npm i` - a fresh clone commits unchecked until the one-time command
+# in .github/CONTRIBUTING.md is run by hand.
+#
+# This file is the standard route instead: install the framework once with
+# `pre-commit install`, and the secret scan runs on every commit. The hook is
+# pinned to an exact gitleaks release tag.
+repos:
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.30.1
+    hooks:
+      - id: gitleaks

package/README.md

@@ -35,11 +35,14 @@ Configuration is via a `.sasjslint` file with the following structure (these are
   "maxLineLength": 80,
   "noEncodedPasswords": true,
   "noNestedMacros": true,
+  "noSingleAsteriskComments": false,
   "noGremlins": true,
   "noSpacesInFileNames": true,
   "noTabs": true,
   "noTrailingSpaces": true,
-  "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}  <h4> SAS Macros </h4>{lineEnding}**/"
+  "noUndeclaredMacros": true,
+  "noUnusedMacros": true,
+  "defaultHeader": "/**{lineEnding}  @file{lineEnding}  @brief <Your brief here>{lineEnding}{lineEnding}  <h4> SAS Macros </h4>{lineEnding}{lineEnding}**/"
 }
 ```
 
@@ -78,10 +81,14 @@ The default header is as follows:
 /**
   @file
   @brief <Your brief here>
+
   <h4> SAS Macros </h4>
+
 **/
 ```
 
+A blank line separates the `<h4> SAS Macros </h4>` section from the header content before it and from whatever follows the list. The same blank-line convention applies to the `<h4> Other Macros </h4>` section.
+
 If creating a new value, use `{lineEnding}` instead of `\n`, eg as follows:
 
 ```json
@@ -237,6 +244,23 @@ Where macros are defined inside other macros, they are recompiled every time the
 - Default: true
 - Severity: WARNING
 
+### noSingleAsteriskComments
+
+SAS supports a comment statement that begins with a single asterisk and runs to the next semicolon, for example `* some text;`. This style is easy to mistype - a missing terminating semicolon turns the rest of the program into a comment - and it cannot be nested, so the SASjs framework recommends block comments (`/* ... */`) instead.
+
+This rule reports a warning for each comment statement that begins with a single asterisk. It ignores asterisks inside quoted strings, `%str()` / `%nrstr()` arguments, macro comments (`%* ... ;`), data sections (`datalines` / `cards`), `proc lua` / `proc groovy` submit blocks and arithmetic expressions (`a * b`, `b ** a`, `select * from`), so it only fires on genuine comment statements.
+
+- Default: false
+- Severity: WARNING
+
+Example:
+
+```json
+{
+  "noSingleAsteriskComments": true
+}
+```
+
 ### noSpacesInFileNames
 
 The 'beef' we have with spaces in filenames is twofold:
@@ -271,6 +295,27 @@ This will highlight lines with trailing spaces. Trailing spaces serve no useful
 - Default: true
 - severity: WARNING
 
+### noUndeclaredMacros
+
+SASjs programs declare the macros they use in the `<h4> SAS Macros </h4>` section of the header, so that the compiler can assemble the job before it runs. This rule reports a warning for each macro that a file invokes without declaring it - either by defining it in the file, or by listing it under `<h4> SAS Macros </h4>` or `<h4> Other Macros </h4>`.
+
+The macros that ship with SAS (`%scan`, `%index`, `%sysfunc` and the other macro functions, along with the macro language keywords such as `%if`, `%then` and `%do`) are always considered declared, so they are never reported. That list is generated from the `macroStatements` and `macroFunctions` groups of `@sasjs/sas-language` (`npm run generate:macros`), so it tracks the SAS language data rather than being maintained here. Macros made available through the `SASAUTOS` system option are not visible to the linter and will be reported.
+
+The warning is resolved by adding the macro name to the header. Running `sasjs lint fix` (or saving in the SASjs VS Code extension with `formatOnSave`) adds the missing macros automatically, as a unique list sorted alphabetically.
+
+- Default: true
+- Severity: WARNING
+
+### noUnusedMacros
+
+The counterpart of `noUndeclaredMacros`. This rule reports a warning for each macro listed under `<h4> SAS Macros </h4>` that the file itself never invokes, which usually means the header is out of date.
+
+A macro can be referenced indirectly - for example by another macro in the dependency chain, or through a dynamic `%&macro` call - without appearing as a direct invocation in the file, so the warning is advisory.
+
+Running `sasjs lint fix` (or saving in the SASjs VS Code extension with `formatOnSave`) removes the unused entries from the header. Together with `noUndeclaredMacros`, this leaves the `<h4> SAS Macros </h4>` section listing exactly the macros the file uses.
+
+- Default: true
+- Severity: WARNING
 
 ## severityLevel
 
@@ -300,6 +345,8 @@ We've already implemented the following rules:
 
 - Add the macro name to the %mend statement
 - Add a doxygen header template if none exists
+- Add undeclared macros to the `<h4> SAS Macros </h4>` section
+- Remove unused macros from the `<h4> SAS Macros </h4>` section
 - Remove trailing spaces
 
 We're looking to implement the following rules:
@@ -307,6 +354,7 @@ We're looking to implement the following rules:
 - Change tabs to spaces
 - zap gremlins
 - fix line endings
+- convert single asterisk comments to block comments
 
 We are also investigating some harder stuff, such as automatic indentation and code layout
 

package/package.json

@@ -3,15 +3,15 @@
   "description": "Linting and formatting for SAS code",
   "scripts": {
     "test": "jest --coverage",
-    "build": "npx rimraf build && tsc",
+    "build": "rimraf build && tsc",
+    "generate:macros": "node ./scripts/generate-macro-names.mjs",
     "preinstall": "node checkNodeVersion",
     "prebuild": "node checkNodeVersion",
     "publishInit": "cp -r ./build/* . && rm -rf ./build && rm -rf ./src && rm tsconfig.json",
     "package:lib": "npm run build && cp ./package.json ./checkNodeVersion.js build && cp README.md build && cd build && npm version \"5.0.0\" && npm pack",
     "lint:fix": "npx prettier --write \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
     "lint": "npx prettier --check \"{src,test}/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
-    "prepare": "git rev-parse --git-dir && git config core.hooksPath ./.git-hooks || true",
-    "audit": "node scripts/audit.mjs"
+    "prepare": "git rev-parse --git-dir && git config core.hooksPath ./.git-hooks || true"
   },
   "publishConfig": {
     "access": "public"
@@ -59,18 +59,18 @@
   },
   "homepage": "https://github.com/sasjs/lint#readme",
   "devDependencies": {
-    "@semantic-release/exec": "6.0.3",
-    "@semantic-release/git": "10.0.1",
+    "@nogoo9/gitleaks": "8.30.1-post.2",
+    "@sasjs/sas-language": "0.3.0",
     "@types/jest": "30.0.0",
-    "@types/node": "26.4.1",
-    "jest": "30.5.1",
-    "semantic-release": "25.0.8",
-    "ts-jest": "29.4.12",
-    "typescript": "5.9.3"
+    "@types/node": "26.6.3",
+    "jest": "30.5.2",
+    "rimraf": "6.1.3",
+    "ts-jest": "29.4.14",
+    "typescript": "6.0.3"
   },
   "dependencies": {
     "@sasjs/utils": "3.6.2",
-    "ignore": "7.0.8"
+    "ignore": "7.0.11"
   },
-  "version": "2.6.0"
+  "version": "3.0.0"
 }

package/rules/file/index.d.ts

@@ -3,5 +3,8 @@ export { hasMacroNameInMend } from './hasMacroNameInMend';
 export { hasMacroParentheses } from './hasMacroParentheses';
 export { lineEndings } from './lineEndings';
 export { noNestedMacros } from './noNestedMacros';
+export { noUndeclaredMacros } from './noUndeclaredMacros';
+export { noUnusedMacros } from './noUnusedMacros';
 export { strictMacroDefinition } from './strictMacroDefinition';
 export { hasRequiredMacroOptions } from './hasRequiredMacroOptions';
+export { noSingleAsteriskComments } from './noSingleAsteriskComments';

package/rules/file/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasRequiredMacroOptions = exports.strictMacroDefinition = exports.noNestedMacros = exports.lineEndings = exports.hasMacroParentheses = exports.hasMacroNameInMend = exports.hasDoxygenHeader = void 0;
+exports.noSingleAsteriskComments = exports.hasRequiredMacroOptions = exports.strictMacroDefinition = exports.noUnusedMacros = exports.noUndeclaredMacros = exports.noNestedMacros = exports.lineEndings = exports.hasMacroParentheses = exports.hasMacroNameInMend = exports.hasDoxygenHeader = void 0;
 var hasDoxygenHeader_1 = require("./hasDoxygenHeader");
 Object.defineProperty(exports, "hasDoxygenHeader", { enumerable: true, get: function () { return hasDoxygenHeader_1.hasDoxygenHeader; } });
 var hasMacroNameInMend_1 = require("./hasMacroNameInMend");
@@ -11,8 +11,14 @@ var lineEndings_1 = require("./lineEndings");
 Object.defineProperty(exports, "lineEndings", { enumerable: true, get: function () { return lineEndings_1.lineEndings; } });
 var noNestedMacros_1 = require("./noNestedMacros");
 Object.defineProperty(exports, "noNestedMacros", { enumerable: true, get: function () { return noNestedMacros_1.noNestedMacros; } });
+var noUndeclaredMacros_1 = require("./noUndeclaredMacros");
+Object.defineProperty(exports, "noUndeclaredMacros", { enumerable: true, get: function () { return noUndeclaredMacros_1.noUndeclaredMacros; } });
+var noUnusedMacros_1 = require("./noUnusedMacros");
+Object.defineProperty(exports, "noUnusedMacros", { enumerable: true, get: function () { return noUnusedMacros_1.noUnusedMacros; } });
 var strictMacroDefinition_1 = require("./strictMacroDefinition");
 Object.defineProperty(exports, "strictMacroDefinition", { enumerable: true, get: function () { return strictMacroDefinition_1.strictMacroDefinition; } });
 var hasRequiredMacroOptions_1 = require("./hasRequiredMacroOptions");
 Object.defineProperty(exports, "hasRequiredMacroOptions", { enumerable: true, get: function () { return hasRequiredMacroOptions_1.hasRequiredMacroOptions; } });
+var noSingleAsteriskComments_1 = require("./noSingleAsteriskComments");
+Object.defineProperty(exports, "noSingleAsteriskComments", { enumerable: true, get: function () { return noSingleAsteriskComments_1.noSingleAsteriskComments; } });
 //# sourceMappingURL=index.js.map

package/rules/file/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rules/file/index.ts"],"names":[],"mappings":";;;AAAA,uDAAqD;AAA5C,oHAAA,gBAAgB,OAAA;AACzB,2DAAyD;AAAhD,wHAAA,kBAAkB,OAAA;AAC3B,6DAA2D;AAAlD,0HAAA,mBAAmB,OAAA;AAC5B,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AACpB,mDAAiD;AAAxC,gHAAA,cAAc,OAAA;AACvB,iEAA+D;AAAtD,8HAAA,qBAAqB,OAAA;AAC9B,qEAAmE;AAA1D,kIAAA,uBAAuB,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rules/file/index.ts"],"names":[],"mappings":";;;AAAA,uDAAqD;AAA5C,oHAAA,gBAAgB,OAAA;AACzB,2DAAyD;AAAhD,wHAAA,kBAAkB,OAAA;AAC3B,6DAA2D;AAAlD,0HAAA,mBAAmB,OAAA;AAC5B,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AACpB,mDAAiD;AAAxC,gHAAA,cAAc,OAAA;AACvB,2DAAyD;AAAhD,wHAAA,kBAAkB,OAAA;AAC3B,mDAAiD;AAAxC,gHAAA,cAAc,OAAA;AACvB,iEAA+D;AAAtD,8HAAA,qBAAqB,OAAA;AAC9B,qEAAmE;AAA1D,kIAAA,uBAAuB,OAAA;AAChC,uEAAqE;AAA5D,oIAAA,wBAAwB,OAAA"}

package/rules/file/noSingleAsteriskComments.d.ts

@@ -0,0 +1,7 @@
+import { FileLintRule } from '../../types/LintRule';
+/**
+ * Lint rule that checks for SAS comment statements that begin with a single
+ * asterisk, such as `* some text;`. These are easy to mistype and should be
+ * written as block comments instead.
+ */
+export declare const noSingleAsteriskComments: FileLintRule;

package/rules/file/noSingleAsteriskComments.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noSingleAsteriskComments = void 0;
+const LintRuleType_1 = require("../../types/LintRuleType");
+const Severity_1 = require("../../types/Severity");
+const name = 'noSingleAsteriskComments';
+const description = 'Disallow comment statements that begin with a single asterisk (*).';
+const message = 'Line contains a single asterisk comment';
+/**
+ * Matches the statements that open a data section. The `4` variants are
+ * terminated by `;;;;`, the others by a semicolon.
+ */
+const dataSectionStart = /^(datalines4?|cards4?|parmcards4?)\s*;/i;
+/**
+ * Matches the functions whose argument is data rather than code.
+ */
+const maskingFunctionStart = /^%(nrstr|str)\s*\(/i;
+/**
+ * Matches the procedures whose `submit` block holds another language, so SAS
+ * statement rules do not apply inside it.
+ */
+const embeddedLanguageProc = /^proc\s+(lua|groovy)\b/i;
+/**
+ * Matches the statement that closes an embedded-language block.
+ */
+const embeddedLanguageEnd = /^endsubmit\s*;/i;
+const embeddedLanguageEndSearch = /endsubmit/i;
+const test = (value, config) => {
+    const severity = (config === null || config === void 0 ? void 0 : config.severityLevel[name]) || Severity_1.Severity.Warning;
+    const diagnostics = [];
+    const length = value.length;
+    let index = 0;
+    let lineNumber = 1;
+    let columnNumber = 1;
+    let atStatementStart = true;
+    let embeddedProc = false;
+    /**
+     * Advances the cursor to `target`, keeping the line and column counters in
+     * step. Every branch that consumes a non-code region moves through here.
+     */
+    const advanceTo = (target) => {
+        const limit = Math.min(target, length);
+        while (index < limit) {
+            if (value[index] === '\n') {
+                lineNumber++;
+                columnNumber = 1;
+            }
+            else {
+                columnNumber++;
+            }
+            index++;
+        }
+    };
+    while (index < length) {
+        const char = value[index];
+        if (char === '\n') {
+            lineNumber++;
+            columnNumber = 1;
+            index++;
+            continue;
+        }
+        if (char === '\r' || char === ' ' || char === '\t') {
+            columnNumber++;
+            index++;
+            continue;
+        }
+        if (char === ';') {
+            atStatementStart = true;
+            columnNumber++;
+            index++;
+            continue;
+        }
+        // Block comment - /* ... */
+        if (char === '/' && value[index + 1] === '*') {
+            let end = index + 2;
+            while (end < length && !(value[end] === '*' && value[end + 1] === '/')) {
+                end++;
+            }
+            advanceTo(Math.min(end + 2, length));
+            continue;
+        }
+        // Macro comment - %* ... ;
+        if (char === '%' && value[index + 1] === '*') {
+            let end = index + 2;
+            while (end < length && value[end] !== ';')
+                end++;
+            advanceTo(Math.min(end + 1, length));
+            continue;
+        }
+        // Masking functions - the argument is data, not code. `%(` and `%)` are
+        // the escapes for literal parentheses inside the argument, so they do not
+        // affect the nesting depth.
+        const maskingFunction = maskingFunctionStart.exec(value.slice(index));
+        if (maskingFunction) {
+            let depth = 0;
+            let end = index + maskingFunction[0].length - 1;
+            while (end < length) {
+                if (value[end] === '%' &&
+                    (value[end + 1] === '(' || value[end + 1] === ')')) {
+                    end += 2;
+                    continue;
+                }
+                if (value[end] === '(')
+                    depth++;
+                else if (value[end] === ')') {
+                    depth--;
+                    if (depth === 0) {
+                        end++;
+                        break;
+                    }
+                }
+                end++;
+            }
+            advanceTo(end);
+            continue;
+        }
+        // Quoted string literal - '' and "" are escaped quote characters.
+        if (char === "'" || char === '"') {
+            let end = index + 1;
+            while (end < length) {
+                if (value[end] === char) {
+                    if (value[end + 1] === char) {
+                        end += 2;
+                        continue;
+                    }
+                    end++;
+                    break;
+                }
+                if (value[end] === '\n')
+                    break;
+                end++;
+            }
+            advanceTo(end);
+            continue;
+        }
+        if (atStatementStart) {
+            // Inside a proc lua / proc groovy submit block - the code is another
+            // language, so SAS statement rules do not apply to it.
+            if (embeddedProc) {
+                const endSubmit = embeddedLanguageEnd.exec(value.slice(index));
+                if (endSubmit) {
+                    embeddedProc = false;
+                    advanceTo(index + endSubmit[0].length);
+                    atStatementStart = true;
+                    continue;
+                }
+                advanceTo(index + value.slice(index).search(embeddedLanguageEndSearch));
+                atStatementStart = true;
+                continue;
+            }
+            // proc lua / proc groovy opens an embedded-language block. Only enter
+            // the block when it is closed, so a stray `proc lua;` cannot swallow
+            // the rest of the file.
+            const embeddedProcStart = embeddedLanguageProc.exec(value.slice(index));
+            if (embeddedProcStart &&
+                embeddedLanguageEndSearch.test(value.slice(index))) {
+                embeddedProc = true;
+                advanceTo(index + embeddedProcStart[0].length);
+                atStatementStart = false;
+                continue;
+            }
+            // A data section - everything up to its terminating line is data, not
+            // code. The terminator is a line containing only the `;` or `;;;;`.
+            const dataSection = dataSectionStart.exec(value.slice(index));
+            if (dataSection) {
+                const terminator = /4/.test(dataSection[1]) ? ';;;;' : ';';
+                let lineStart = index + dataSection[0].length;
+                let end = length;
+                while (lineStart <= length) {
+                    const lineEnd = value.indexOf('\n', lineStart);
+                    const actualEnd = lineEnd === -1 ? length : lineEnd;
+                    if (value.slice(lineStart, actualEnd).trim() === terminator) {
+                        end = actualEnd;
+                        break;
+                    }
+                    if (lineEnd === -1)
+                        break;
+                    lineStart = lineEnd + 1;
+                }
+                advanceTo(end);
+                atStatementStart = true;
+                continue;
+            }
+            // A comment statement - its body is opaque up to the terminating `;`.
+            if (char === '*') {
+                diagnostics.push({
+                    message,
+                    lineNumber,
+                    startColumnNumber: columnNumber,
+                    endColumnNumber: columnNumber + 1,
+                    severity
+                });
+                let end = index + 1;
+                while (end < length && value[end] !== ';')
+                    end++;
+                advanceTo(end + 1);
+                atStatementStart = true;
+                continue;
+            }
+        }
+        atStatementStart = false;
+        columnNumber++;
+        index++;
+    }
+    return diagnostics;
+};
+/**
+ * Lint rule that checks for SAS comment statements that begin with a single
+ * asterisk, such as `* some text;`. These are easy to mistype and should be
+ * written as block comments instead.
+ */
+exports.noSingleAsteriskComments = {
+    type: LintRuleType_1.LintRuleType.File,
+    name,
+    description,
+    message,
+    test
+};
+//# sourceMappingURL=noSingleAsteriskComments.js.map

package/rules/file/noSingleAsteriskComments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noSingleAsteriskComments.js","sourceRoot":"","sources":["../../../src/rules/file/noSingleAsteriskComments.ts"],"names":[],"mappings":"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"}

package/rules/file/noUndeclaredMacros.d.ts

@@ -0,0 +1,7 @@
+import { FileLintRule } from '../../types/LintRule';
+/**
+ * Lint rule that reports each macro a file uses without declaring it in the
+ * header. The formatter resolves the warning by adding the macro names to the
+ * `<h4> SAS Macros </h4>` section.
+ */
+export declare const noUndeclaredMacros: FileLintRule;

package/rules/file/noUndeclaredMacros.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noUndeclaredMacros = void 0;
+const types_1 = require("../../types");
+const LintRuleType_1 = require("../../types/LintRuleType");
+const Severity_1 = require("../../types/Severity");
+const headerMacros_1 = require("../../utils/headerMacros");
+const parseMacroCalls_1 = require("../../utils/parseMacroCalls");
+const parseMacros_1 = require("../../utils/parseMacros");
+const sasMacros_1 = require("../../utils/sasMacros");
+const name = 'noUndeclaredMacros';
+const description = 'Enforce that every macro used in a file is declared.';
+const message = `Macro '{macro}' is not declared - add it to the <h4> SAS Macros </h4> or <h4> Other Macros </h4> section of the header`;
+/**
+ * Collects the first invocation of each macro that the file uses but does not
+ * declare. A macro is declared when it is defined in the file, or listed in the
+ * `<h4> SAS Macros </h4>` or `<h4> Other Macros </h4>` section of its header.
+ * Macros that ship with SAS are always considered declared.
+ */
+const getUndeclaredCalls = (value, config) => {
+    if (!value)
+        return [];
+    const declared = new Set();
+    (0, parseMacros_1.parseMacros)(value, config).forEach((macro) => {
+        if (macro.name)
+            declared.add(macro.name.toLowerCase());
+    });
+    (0, headerMacros_1.getHeaderMacros)(value, config).forEach((macro) => {
+        declared.add(macro.name.toLowerCase());
+    });
+    const undeclared = [];
+    const seen = new Set();
+    (0, parseMacroCalls_1.parseMacroCalls)(value, config).forEach((call) => {
+        const key = call.name.toLowerCase();
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        if ((0, sasMacros_1.isSasMacro)(call.name))
+            return;
+        if (declared.has(key))
+            return;
+        undeclared.push(call);
+    });
+    return undeclared;
+};
+const test = (value, config) => {
+    const cfg = config || new types_1.LintConfig();
+    const severity = cfg.severityLevel[name] || Severity_1.Severity.Warning;
+    return getUndeclaredCalls(value, cfg).map((call) => ({
+        message: message.replace('{macro}', call.name),
+        lineNumber: call.lineNumber,
+        startColumnNumber: call.startColumnNumber,
+        endColumnNumber: call.endColumnNumber,
+        severity
+    }));
+};
+const fix = (value, config) => {
+    const cfg = config || new types_1.LintConfig();
+    const macros = getUndeclaredCalls(value, cfg).map((call) => call.name);
+    if (!macros.length)
+        return value;
+    return (0, headerMacros_1.addMacrosToHeader)(value, cfg, macros);
+};
+/**
+ * Lint rule that reports each macro a file uses without declaring it in the
+ * header. The formatter resolves the warning by adding the macro names to the
+ * `<h4> SAS Macros </h4>` section.
+ */
+exports.noUndeclaredMacros = {
+    type: LintRuleType_1.LintRuleType.File,
+    name,
+    description,
+    message,
+    test,
+    fix
+};
+//# sourceMappingURL=noUndeclaredMacros.js.map

package/rules/file/noUndeclaredMacros.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noUndeclaredMacros.js","sourceRoot":"","sources":["../../../src/rules/file/noUndeclaredMacros.ts"],"names":[],"mappings":"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"}

package/rules/file/noUnusedMacros.d.ts

@@ -0,0 +1,7 @@
+import { FileLintRule } from '../../types/LintRule';
+/**
+ * Lint rule that reports macros declared in the `<h4> SAS Macros </h4>` section
+ * of a file header that the file itself never invokes. The formatter removes
+ * them from the header.
+ */
+export declare const noUnusedMacros: FileLintRule;