eslint-plugin-sfmc 2.6.1 → 3.0.0

package/src/handlebars-parser.js

@@ -0,0 +1,195 @@
+/**
+ * ESLint-compatible parser for Marketing Cloud Next Handlebars.
+ *
+ * Wraps the `@handlebars/parser` package and adds the metadata ESLint needs:
+ *   - `range: [start, end]` on every node (derived from the parser's
+ *     1-based-line / 0-based-column `loc` via a line-start table)
+ *   - `loc: { start: {line,column}, end: {line,column} }` (kept from the parser,
+ *     whose convention already matches ESLint: 1-based line, 0-based column)
+ *   - Root node typed as "Program" with `body`, `tokens`, `comments`
+ *   - `visitorKeys` so ESLint knows how to traverse Handlebars node types
+ *
+ * AMPscript regions inside the source must be blanked out before this parser
+ * runs (the processor does this) so Handlebars never sees `%%[ ... ]%%` syntax.
+ */
+
+import { parse as hbsParse } from '@handlebars/parser';
+
+// ── Node renaming for ESTree collisions ───────────────────────────────────
+//
+// `BlockStatement` is also an ESTree node type, so ESLint's built-in scope
+// analysis (eslint-scope) tries to open a lexical scope for it and crashes on
+// the Handlebars shape. Likewise, a Handlebars `BlockStatement` contains nested
+// `Program` nodes (its `program`/`inverse` bodies); eslint-scope treats every
+// `Program` as a global scope and asserts when they nest. Rename both to
+// Hbs-prefixed types so the JS analyzer leaves them alone — only the single
+// synthetic root keeps the real `Program` type. The hbs rules and visitorKeys
+// reference the renamed types.
+
+const NODE_RENAME = {
+    BlockStatement: 'HbsBlockStatement',
+    Program: 'HbsProgram',
+};
+
+// ── Visitor keys for all Handlebars AST node types ────────────────────────
+
+export const visitorKeys = {
+    Program: ['body'],
+    HbsProgram: ['body'],
+    MustacheStatement: ['path', 'params', 'hash'],
+    HbsBlockStatement: ['path', 'params', 'hash', 'program', 'inverse'],
+    PartialStatement: ['name', 'params', 'hash'],
+    PartialBlockStatement: ['name', 'params', 'hash', 'program'],
+    DecoratorBlock: ['path', 'params', 'hash', 'program'],
+    Decorator: ['path', 'params', 'hash'],
+    ContentStatement: [],
+    CommentStatement: [],
+    SubExpression: ['path', 'params', 'hash'],
+    PathExpression: [],
+    StringLiteral: [],
+    NumberLiteral: [],
+    BooleanLiteral: [],
+    UndefinedLiteral: [],
+    NullLiteral: [],
+    Hash: ['pairs'],
+    HashPair: ['value'],
+};
+
+// ── line/column → offset mapping ──────────────────────────────────────────
+
+function buildLineTable(text) {
+    const starts = [0];
+    for (let index = 0; index < text.length; index++) {
+        if (text[index] === '\n') {
+            starts.push(index + 1);
+        } else if (text[index] === '\r') {
+            if (text[index + 1] === '\n') {
+                starts.push(index + 2);
+                index++;
+            } else {
+                starts.push(index + 1);
+            }
+        }
+    }
+    return starts;
+}
+
+function locToOffset(position, lineStarts, textLength) {
+    if (!position || typeof position.line !== 'number') {
+        return 0;
+    }
+    const lineIndex = Math.max(0, position.line - 1);
+    const base = lineIndex < lineStarts.length ? lineStarts[lineIndex] : textLength;
+    const offset = base + Math.max(0, position.column);
+    return Math.min(offset, textLength);
+}
+
+// ── AST annotation ────────────────────────────────────────────────────────
+
+function annotateNode(node, lineStarts, textLength, fallback) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+
+    // Rename colliding ESTree types so ESLint's JS scope analysis ignores them.
+    if (node.type && Object.hasOwn(NODE_RENAME, node.type)) {
+        node.type = NODE_RENAME[node.type];
+    }
+
+    // ESLint requires every traversed node to expose a numeric `range` and a
+    // matching `loc`. `@handlebars/parser` attaches `loc` to most nodes but a
+    // few (e.g. Hash, HashPair) can omit it — inherit the parent's span so the
+    // traverser never sees an undefined range.
+    let span = fallback;
+    if (node.loc && node.loc.start && node.loc.end) {
+        const start = locToOffset(node.loc.start, lineStarts, textLength);
+        const end = locToOffset(node.loc.end, lineStarts, textLength);
+        node.range = [start, end];
+        node.start = start;
+        node.end = end;
+        node.loc = {
+            start: { line: node.loc.start.line, column: node.loc.start.column },
+            end: { line: node.loc.end.line, column: node.loc.end.column },
+        };
+        span = { range: node.range, loc: node.loc };
+    } else if (fallback) {
+        node.range = [...fallback.range];
+        node.start = fallback.range[0];
+        node.end = fallback.range[1];
+        node.loc = {
+            start: { ...fallback.loc.start },
+            end: { ...fallback.loc.end },
+        };
+    }
+
+    const keys = visitorKeys[node.type];
+    if (!keys) {
+        return;
+    }
+
+    for (const key of keys) {
+        const child = node[key];
+        if (Array.isArray(child)) {
+            for (const item of child) {
+                if (item && typeof item === 'object') {
+                    annotateNode(item, lineStarts, textLength, span);
+                }
+            }
+        } else if (child && typeof child === 'object') {
+            annotateNode(child, lineStarts, textLength, span);
+        }
+    }
+}
+
+// ── Public ESLint parser interface ────────────────────────────────────────
+
+export function parseForESLint(code) {
+    const lineStarts = buildLineTable(code);
+
+    let handlebarsAst;
+    try {
+        handlebarsAst = hbsParse(code);
+    } catch (ex) {
+        const loc = ex && ex.hash && ex.hash.loc;
+        const rawMessage = (ex && ex.message) || 'Handlebars syntax error.';
+        const messageLines = rawMessage.split('\n').filter((line) => line.trim().length > 0);
+        const error = new SyntaxError(messageLines.at(-1) || rawMessage);
+        error.lineNumber = loc ? Math.max(1, loc.first_line) : 1;
+        error.column = loc ? Math.max(1, loc.first_column + 1) : 1;
+        throw error;
+    }
+
+    const ast = {
+        type: 'Program',
+        body: handlebarsAst.body || [],
+        start: 0,
+        end: code.length,
+        range: [0, code.length],
+        loc: {
+            start: { line: 1, column: 0 },
+            end: handlebarsAst.loc
+                ? { line: handlebarsAst.loc.end.line, column: handlebarsAst.loc.end.column }
+                : {
+                      line: lineStarts.length,
+                      column: code.length - lineStarts.at(-1),
+                  },
+        },
+        tokens: [],
+        comments: [],
+    };
+
+    for (const child of ast.body) {
+        annotateNode(child, lineStarts, code.length);
+    }
+
+    return {
+        ast,
+        visitorKeys,
+        services: {},
+        scopeManager: null,
+    };
+}
+
+export function parse(code) {
+    return parseForESLint(code).ast;
+}

package/src/index.js

@@ -10,11 +10,12 @@
  */
 
 import * as ampscriptParser from './ampscript-parser.js';
+import * as handlebarsParser from './handlebars-parser.js';
 
 // ── AMPscript rules ───────────────────────────────────────────────────────────
 
 import ampNoUnknownFunction from './rules/amp/no-unknown-function.js';
-import ampNoVariableRedeclaration from './rules/amp/no-var-redeclaration.js';
+import ampNoVariableRedeclaration from './rules/amp/no-variable-redeclaration.js';
 import ampSetRequiresTarget from './rules/amp/set-requires-target.js';
 import ampNoEmptyBlock from './rules/amp/no-empty-block.js';
 import ampNoSmartQuotes from './rules/amp/no-smart-quotes.js';
@@ -23,7 +24,7 @@ import ampNoLoopCounterAssign from './rules/amp/no-loop-counter-assign.js';
 import ampNoInlineStatement from './rules/amp/no-inline-statement.js';
 import ampRequireVariableDeclaration from './rules/amp/require-variable-declaration.js';
 import ampFunctionArity from './rules/amp/function-arity.js';
-import ampArgTypes from './rules/amp/arg-types.js';
+import ampArgumentTypes from './rules/amp/argument-types.js';
 import ampNoEmailExcludedFunction from './rules/amp/no-email-excluded-function.js';
 import ampNoDeprecatedFunction from './rules/amp/no-deprecated-function.js';
 import ampNamingConvention from './rules/amp/naming-convention.js';
@@ -48,12 +49,20 @@ import ssjsRequirePlatformLoadOrder from './rules/ssjs/require-platform-load-ord
 import ssjsNoHardcodedCredentials from './rules/ssjs/no-hardcoded-credentials.js';
 import ssjsPreferPlatformLoadVersion from './rules/ssjs/prefer-platform-load-version.js';
 import ssjsNoUnavailableMethod from './rules/ssjs/no-unavailable-method.js';
-import ssjsPreferParsejsonSafeArg from './rules/ssjs/prefer-parsejson-safe-arg.js';
+import ssjsPreferParsejsonSafeArgument from './rules/ssjs/prefer-parsejson-safe-argument.js';
 import ssjsNoSwitchDefault from './rules/ssjs/no-switch-default.js';
 import ssjsNoTreatAsContentInjection from './rules/ssjs/no-treatascontent-injection.js';
-import ssjsArgTypes from './rules/ssjs/ssjs-arg-types.js';
+import ssjsArgumentTypes from './rules/ssjs/ssjs-argument-types.js';
 import ssjsCoreMethodArity from './rules/ssjs/ssjs-core-method-arity.js';
 
+// ── Handlebars (MCN) rules ──────────────────────────────────────────────────────
+
+import hbsNoUnknownHelper from './rules/hbs/no-unknown-helper.js';
+import hbsHelperTooNewForTarget from './rules/hbs/helper-too-new-for-target.js';
+import hbsNoUnknownBinding from './rules/hbs/no-unknown-binding.js';
+import hbsHelperArity from './rules/hbs/helper-arity.js';
+import hbsNoUnsupportedConstruct from './rules/hbs/no-unsupported-construct.js';
+
 // ── Processors ────────────────────────────────────────────────────────────────
 
 import ampscriptProcessor from './ampscript-processor.js';
@@ -83,7 +92,7 @@ const plugin = {
         'amp-no-inline-statement': ampNoInlineStatement,
         'amp-require-variable-declaration': ampRequireVariableDeclaration,
         'amp-function-arity': ampFunctionArity,
-        'amp-arg-types': ampArgTypes,
+        'amp-arg-types': ampArgumentTypes,
         'amp-no-email-excluded-function': ampNoEmailExcludedFunction,
         'amp-no-deprecated-function': ampNoDeprecatedFunction,
         'amp-naming-convention': ampNamingConvention,
@@ -107,11 +116,18 @@ const plugin = {
         'ssjs-no-hardcoded-credentials': ssjsNoHardcodedCredentials,
         'ssjs-prefer-platform-load-version': ssjsPreferPlatformLoadVersion,
         'ssjs-no-unavailable-method': ssjsNoUnavailableMethod,
-        'ssjs-prefer-parsejson-safe-arg': ssjsPreferParsejsonSafeArg,
+        'ssjs-prefer-parsejson-safe-arg': ssjsPreferParsejsonSafeArgument,
         'ssjs-no-switch-default': ssjsNoSwitchDefault,
         'ssjs-no-treatascontent-injection': ssjsNoTreatAsContentInjection,
-        'ssjs-arg-types': ssjsArgTypes,
+        'ssjs-arg-types': ssjsArgumentTypes,
         'ssjs-core-method-arity': ssjsCoreMethodArity,
+
+        // Handlebars (MCN) rules (hbs- prefix)
+        'hbs-no-unknown-helper': hbsNoUnknownHelper,
+        'hbs-helper-too-new-for-target': hbsHelperTooNewForTarget,
+        'hbs-no-unknown-binding': hbsNoUnknownBinding,
+        'hbs-helper-arity': hbsHelperArity,
+        'hbs-no-unsupported-construct': hbsNoUnsupportedConstruct,
     },
 
     processors: {
@@ -119,8 +135,6 @@ const plugin = {
         ssjs: ssjsProcessor,
         sfmc: combinedProcessor,
     },
-
-    configs: {},
 };
 
 // ── MCN SSJS rule set (all SSJS rules off except ssjs-no-unknown-function) ────
@@ -240,9 +254,40 @@ const ssjsStrictRules = {
     'no-cond-assign': 'error',
 };
 
+// ── Handlebars (MCN) rule sets ────────────────────────────────────────────────
+
+/**
+ * Handlebars rules for Marketing Cloud Next targets. Handlebars only exists when
+ * targeting MCN, so these are enabled only in `-next` configs and applied to the
+ * virtual `.hbs` files the combined processor extracts from HTML.
+ */
+const hbsNextRules = {
+    'sfmc/hbs-no-unknown-helper': 'error',
+    'sfmc/hbs-no-unknown-binding': 'error',
+    'sfmc/hbs-helper-arity': 'error',
+    'sfmc/hbs-no-unsupported-construct': 'error',
+    'sfmc/hbs-helper-too-new-for-target': 'off',
+};
+
+/**
+ * Handlebars rules for non-MCN (classic) targets — all disabled. Classic SFMC
+ * does not run Handlebars, so any `{{...}}` is plain content and must not be
+ * flagged.
+ */
+const hbsOffRules = {
+    'sfmc/hbs-no-unknown-helper': 'off',
+    'sfmc/hbs-no-unknown-binding': 'off',
+    'sfmc/hbs-helper-arity': 'off',
+    'sfmc/hbs-no-unsupported-construct': 'off',
+    'sfmc/hbs-helper-too-new-for-target': 'off',
+};
+
+/** Shared languageOptions for linting virtual `.hbs` files. */
+const hbsLanguageOptions = { parser: handlebarsParser };
+
 // ── Configs (defined after plugin so they can reference it) ───────────────────
 
-Object.assign(plugin.configs, {
+plugin.configs = {
     /**
      * AMPscript-only config for standalone .ampscript/.amp files.
      */
@@ -323,6 +368,16 @@ Object.assign(plugin.configs, {
             },
             rules: { ...ssjsRecommendedRules },
         },
+        {
+            // Classic (non-MCN) HTML: Handlebars is not executed, so all hbs
+            // rules are off. The parser is still required so the extracted .hbs
+            // virtual file is not handed to espree.
+            name: 'sfmc/embedded-handlebars-rules',
+            plugins: { sfmc: plugin },
+            languageOptions: { ...hbsLanguageOptions },
+            files: ['**/*.html/*.hbs'],
+            rules: { ...hbsOffRules },
+        },
     ],
 
     /**
@@ -371,6 +426,14 @@ Object.assign(plugin.configs, {
             },
             rules: { ...ssjsStrictRules },
         },
+        {
+            // Classic (non-MCN) HTML: Handlebars rules off, parser still wired.
+            name: 'sfmc/strict-embedded-handlebars-rules',
+            plugins: { sfmc: plugin },
+            languageOptions: { ...hbsLanguageOptions },
+            files: ['**/*.html/*.hbs'],
+            rules: { ...hbsOffRules },
+        },
     ],
 
     // ── Marketing Cloud Next configs ──────────────────────────────────────────
@@ -464,6 +527,14 @@ Object.assign(plugin.configs, {
             },
             rules: { ...ssjsMcnRules },
         },
+        {
+            // MCN HTML: Handlebars is the templating language — enable hbs rules.
+            name: 'sfmc/embedded-next-handlebars-rules',
+            plugins: { sfmc: plugin },
+            languageOptions: { ...hbsLanguageOptions },
+            files: ['**/*.html/*.hbs'],
+            rules: { ...hbsNextRules },
+        },
     ],
 
     /**
@@ -518,7 +589,15 @@ Object.assign(plugin.configs, {
             },
             rules: { ...ssjsMcnRules },
         },
+        {
+            // MCN HTML (strict): all Handlebars rules at error severity.
+            name: 'sfmc/strict-next-embedded-handlebars-rules',
+            plugins: { sfmc: plugin },
+            languageOptions: { ...hbsLanguageOptions },
+            files: ['**/*.html/*.hbs'],
+            rules: { ...hbsNextRules },
+        },
     ],
-});
+};
 
 export default plugin;

package/src/processor.js

@@ -1,12 +1,14 @@
 /**
- * Combined SFMC processor that extracts both AMPscript and SSJS regions
- * from HTML files.
+ * Combined SFMC processor that extracts AMPscript, SSJS, and Handlebars
+ * (Marketing Cloud Next) regions from HTML files.
  *
  * Detects:
  *   1. %%[ ... ]%% blocks (with nesting support) → virtual .amp files
  *   2. %%= ... =%% inline expressions → virtual .amp files
  *   3. <script runat="server" language="ampscript"> → virtual .amp files
  *   4. <script runat="server"> (non-ampscript) → virtual .js files
+ *   5. {{ ... }} Handlebars expressions and {!$...} bindings → one virtual .hbs
+ *      file holding the whole document with AMPscript regions blanked out
  *
  * Returns extracted regions as virtual files for ESLint to lint with the
  * appropriate parser/rules based on file extension matching.
@@ -19,6 +21,13 @@ const SSJS_SCRIPT_OPEN_RE =
     /<script\b(?=[^>]*\brunat\s*=\s*['"]server['"])(?![^>]*\blanguage\s*=\s*['"]ampscript['"])[^>]*>/gi;
 const SCRIPT_CLOSE_G = /<\/script\s*>/gi;
 
+/** AMPscript region patterns blanked before the Handlebars parser runs. */
+const AMPSCRIPT_REGION_PATTERNS = [
+    /%%\[[\s\S]*?\]%%/g,
+    /%%=[\s\S]*?=%%/g,
+    /<script\s[^>]*language\s*=\s*["']ampscript["'][^>]*>[\s\S]*?<\/script>/gi,
+];
+
 function countNewlinesBefore(text, pos) {
     let count = 0;
     for (let index = 0; index < pos; index++) {
@@ -29,6 +38,50 @@ function countNewlinesBefore(text, pos) {
     return count;
 }
 
+/**
+ * Scans forward for the closing `=%%` of an inline AMPscript expression.
+ *
+ * @param {string} text - Full document text.
+ * @param {number} from - Index to start scanning from (just past the opening `%%=`).
+ * @returns {number} Index just past the closing `=%%`, or -1 when not found.
+ */
+function findInlineExpressionEnd(text, from) {
+    for (let index = from; index < text.length; index++) {
+        if (text[index] === '=' && text[index + 1] === '%' && text[index + 2] === '%') {
+            return index + 3;
+        }
+    }
+    return -1;
+}
+
+/**
+ * Returns a copy of the document where every AMPscript region is replaced with
+ * spaces, preserving newlines and overall offsets. HTML, Handlebars `{{...}}`
+ * expressions, and `{!$...}` bindings are kept verbatim so the Handlebars
+ * parser can run over a mixed document without choking on AMPscript syntax.
+ *
+ * Mirrors `getSanitizedHandlebarsText` in sfmc-language-lsp.
+ *
+ * @param {string} text - Full document text.
+ * @returns {string} Text with AMPscript regions blanked out.
+ */
+function sanitizeAmpscriptRegions(text) {
+    const chars = Array.from(text);
+    for (const pattern of AMPSCRIPT_REGION_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const end = match.index + match[0].length;
+            for (let index = match.index; index < end && index < chars.length; index++) {
+                if (chars[index] !== '\n' && chars[index] !== '\r') {
+                    chars[index] = ' ';
+                }
+            }
+        }
+    }
+    return chars.join('');
+}
+
 export function preprocess(text, filename) {
     const blocks = [];
     let ampCount = 0;
@@ -92,23 +145,15 @@ export function preprocess(text, filename) {
 
         // %%= ... =%%
         if (text[index] === '%' && text[index + 1] === '%' && text[index + 2] === '=') {
-            const exprStart = index;
-            index += 3;
-            let found = false;
-            while (index < text.length) {
-                if (text[index] === '=' && text[index + 1] === '%' && text[index + 2] === '%') {
-                    index += 3;
-                    found = true;
-                    break;
-                }
-                index++;
-            }
-            if (!found) {
+            const expressionStart = index;
+            const expressionEnd = findInlineExpressionEnd(text, index + 3);
+            if (expressionEnd === -1) {
                 continue;
             }
-            const innerCode = text.slice(exprStart + 3, index - 3);
+            index = expressionEnd;
+            const innerCode = text.slice(expressionStart + 3, index - 3);
             const wrappedBlock = `%%[${innerCode}]%%`;
-            const padding = '\n'.repeat(countNewlinesBefore(text, exprStart));
+            const padding = '\n'.repeat(countNewlinesBefore(text, expressionStart));
             blocks.push({
                 text: padding + wrappedBlock,
                 filename: `${filename}/ampscript-block-${ampCount++}.amp`,
@@ -141,6 +186,21 @@ export function preprocess(text, filename) {
         });
     }
 
+    // --- Pass 3: extract Handlebars (MCN) regions ---
+    // Handlebars expressions and {!$...} bindings can appear anywhere in the
+    // HTML. The Handlebars parser treats surrounding HTML as content, so we emit
+    // the whole document (with AMPscript regions blanked, offsets preserved) as
+    // a single virtual .hbs file. Only emit it when the document actually
+    // contains Handlebars/binding syntax to avoid paying the parse cost on plain
+    // HTML/AMPscript content.
+    const sanitizedForHbs = sanitizeAmpscriptRegions(text);
+    if (sanitizedForHbs.includes('{{') || sanitizedForHbs.includes('{!$')) {
+        blocks.push({
+            text: sanitizedForHbs,
+            filename: `${filename}/handlebars-block-0.hbs`,
+        });
+    }
+
     if (blocks.length === 0) {
         return [text];
     }

package/src/rules/amp/{arg-types.js → argument-types.js}

@@ -25,14 +25,14 @@ const STATIC_LITERAL_TYPES = new Set(['StringLiteral', 'NumberLiteral', 'Boolean
  * literal (e.g. a variable or expression) and cannot be validated against an
  * enum.
  *
- * @param {object} arg - AMPscript argument AST node.
+ * @param {object} argument - AMPscript argument AST node.
  * @returns {string | null} The literal value as a string, or null.
  */
-function staticLiteralValue(arg) {
-    if (!arg || !STATIC_LITERAL_TYPES.has(arg.type)) {
+function staticLiteralValue(argument) {
+    if (!argument || !STATIC_LITERAL_TYPES.has(argument.type)) {
         return null;
     }
-    return String(arg.value);
+    return String(argument.value);
 }
 
 export default {
@@ -58,28 +58,32 @@ export default {
                     return;
                 }
 
-                for (const [i, arg] of node.arguments.entries()) {
-                    const param = entry.params[i];
-                    if (!param || !Array.isArray(param.enum) || param.enum.length === 0) {
+                for (const [index, argument] of node.arguments.entries()) {
+                    const parameter = entry.params[index];
+                    if (
+                        !parameter ||
+                        !Array.isArray(parameter.enum) ||
+                        parameter.enum.length === 0
+                    ) {
                         continue;
                     }
                     // Only validate static literals (string, number, boolean);
                     // variables/expressions cannot be resolved statically.
-                    const actual = staticLiteralValue(arg);
+                    const actual = staticLiteralValue(argument);
                     if (actual === null) {
                         continue;
                     }
-                    const isAllowed = param.enum.some(
+                    const isAllowed = parameter.enum.some(
                         (v) => String(v).toLowerCase() === actual.toLowerCase(),
                     );
                     if (!isAllowed) {
                         context.report({
-                            node: arg,
+                            node: argument,
                             messageId: 'invalidEnumValue',
                             data: {
                                 name: entry.name,
-                                param: param.name,
-                                allowed: param.enum.join(', '),
+                                param: parameter.name,
+                                allowed: parameter.enum.join(', '),
                                 actual,
                             },
                         });

package/src/rules/amp/function-arity.js

@@ -14,7 +14,7 @@ function readIntLiteral(argument) {
     // NumberLiteral / StringLiteral nodes both carry the raw value as a string.
     if (argument.type === 'NumberLiteral' || argument.type === 'StringLiteral') {
         const n = Number(argument.value);
-        return Number.isInteger(n) && n >= 0 ? n : null;
+        return Number.isSafeInteger(n) && n >= 0 ? n : null;
     }
     return null;
 }
@@ -25,15 +25,15 @@ function readIntLiteral(argument) {
  * complete repeating groups, otherwise null.
  *
  * @param {object} entry - ampscript-data function entry (with `repeat`).
- * @param {object[]} args - the call's argument AST nodes.
+ * @param {object[]} callArguments - the call's argument AST nodes.
  * @returns {{messageId: string, data: object} | null} Violation descriptor or null.
  */
-function checkRepeatGroups(entry, args) {
+function checkRepeatGroups(entry, callArguments) {
     const groups = entry.repeat;
     if (!Array.isArray(groups) || groups.length === 0) {
         return null;
     }
-    const actual = args.length;
+    const actual = callArguments.length;
 
     // Single repeating group: trailing args must be a whole multiple of groupSize.
     if (groups.length === 1) {
@@ -57,19 +57,19 @@ function checkRepeatGroups(entry, args) {
     // Two repeating groups (DataExtension Update/Upsert family): the first group's
     // size is dictated by a countParam literal; the second group fills the rest.
     const [g1, g2] = groups;
-    const countArg = g1.countParam
-        ? readIntLiteral(args[entry.params.findIndex((p) => p.name === g1.countParam)])
+    const countArgument = g1.countParam
+        ? readIntLiteral(callArguments[entry.params.findIndex((p) => p.name === g1.countParam)])
         : null;
 
-    if (countArg === null) {
+    if (countArgument === null) {
         // countParam is not a literal we can evaluate; fall back to a parity check:
         // every trailing arg pair must be even across both groups.
         const trailing = actual - g1.startIndex;
         return trailing % g1.groupSize === 0 ? null : incompleteGroup(entry, g1.groupSize);
     }
 
-    const group1Args = countArg * g1.groupSize;
-    const group2Start = g1.startIndex + group1Args;
+    const group1Arguments = countArgument * g1.groupSize;
+    const group2Start = g1.startIndex + group1Arguments;
     const group2Count = actual - group2Start;
     if (group2Count <= 0 || group2Count % g2.groupSize !== 0) {
         return incompleteGroup(entry, g2.groupSize);

package/src/rules/amp/no-inline-statement.js

@@ -29,16 +29,16 @@ export default {
     create(context) {
         return {
             InlineExpression(node) {
-                const expr = node.expression;
-                if (!expr) {
+                const expression = node.expression;
+                if (!expression) {
                     return;
                 }
 
-                if (STATEMENT_TYPES.has(expr.type)) {
+                if (STATEMENT_TYPES.has(expression.type)) {
                     context.report({
-                        node: expr,
+                        node: expression,
                         messageId: 'inlineStatement',
-                        data: { kind: expr.type },
+                        data: { kind: expression.type },
                     });
                 }
             },