eslint-plugin-sfmc 2.6.1 → 4.0.0

package/src/index.js

@@ -10,11 +10,13 @@
  */
 
 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 ampNoMcnUnsupported from './rules/amp/no-mcn-unsupported.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 +25,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';
@@ -39,6 +41,7 @@ import ampNoNestedAmpscriptDelimiter from './rules/amp/no-nested-ampscript-delim
 import ssjsRequirePlatformLoad from './rules/ssjs/require-platform-load.js';
 import ssjsNoUnsupportedSyntax from './rules/ssjs/no-unsupported-syntax.js';
 import ssjsNoUnknownFunction from './rules/ssjs/no-unknown-function.js';
+import ssjsNoMcnUnsupported from './rules/ssjs/no-mcn-unsupported.js';
 import ssjsNoDeprecatedFunction from './rules/ssjs/no-deprecated-function.js';
 import ssjsNoPropertyCall from './rules/ssjs/no-property-call.js';
 import ssjsPlatformFunctionArity from './rules/ssjs/platform-function-arity.js';
@@ -48,12 +51,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 hbsNoMcnUnsupported from './rules/hbs/no-mcn-unsupported.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';
@@ -74,6 +85,7 @@ const plugin = {
     rules: {
         // AMPscript rules (amp- prefix)
         'amp-no-unknown-function': ampNoUnknownFunction,
+        'amp-no-mcn-unsupported': ampNoMcnUnsupported,
         'amp-no-var-redeclaration': ampNoVariableRedeclaration,
         'amp-set-requires-target': ampSetRequiresTarget,
         'amp-no-empty-block': ampNoEmptyBlock,
@@ -83,7 +95,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,
@@ -98,6 +110,7 @@ const plugin = {
         'ssjs-require-platform-load': ssjsRequirePlatformLoad,
         'ssjs-no-unsupported-syntax': ssjsNoUnsupportedSyntax,
         'ssjs-no-unknown-function': ssjsNoUnknownFunction,
+        'ssjs-no-mcn-unsupported': ssjsNoMcnUnsupported,
         'ssjs-no-deprecated-function': ssjsNoDeprecatedFunction,
         'ssjs-no-property-call': ssjsNoPropertyCall,
         'ssjs-platform-function-arity': ssjsPlatformFunctionArity,
@@ -107,11 +120,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-no-mcn-unsupported': hbsNoMcnUnsupported,
+        'hbs-no-unknown-binding': hbsNoUnknownBinding,
+        'hbs-helper-arity': hbsHelperArity,
+        'hbs-no-unsupported-construct': hbsNoUnsupportedConstruct,
     },
 
     processors: {
@@ -119,19 +139,19 @@ const plugin = {
         ssjs: ssjsProcessor,
         sfmc: combinedProcessor,
     },
-
-    configs: {},
 };
 
 // ── MCN SSJS rule set (all SSJS rules off except ssjs-no-unknown-function) ────
 
 /**
  * SSJS rules for MCN targets.
- * All quality rules are disabled — only the presence of SSJS is flagged,
- * because SSJS as a whole must be deleted when targeting Marketing Cloud Next.
+ * All quality rules are disabled — only the presence of SSJS is flagged, via the
+ * dedicated `ssjs-no-mcn-unsupported` rule, because SSJS as a whole must be
+ * deleted when targeting Marketing Cloud Next.
  */
 const ssjsMcnRules = {
-    'sfmc/ssjs-no-unknown-function': ['error', { target: 'next' }],
+    'sfmc/ssjs-no-mcn-unsupported': 'error',
+    'sfmc/ssjs-no-unknown-function': 'off',
     'sfmc/ssjs-require-platform-load': 'off',
     'sfmc/ssjs-no-unsupported-syntax': 'off',
     'sfmc/ssjs-no-deprecated-function': 'off',
@@ -177,7 +197,7 @@ const ampStrictRules = {
     'sfmc/amp-no-unknown-function': 'error',
     'sfmc/amp-no-var-redeclaration': 'error',
     'sfmc/amp-set-requires-target': 'error',
-    'sfmc/amp-no-empty-block': 'error',
+    'sfmc/amp-no-empty-block': 'warn',
     'sfmc/amp-no-smart-quotes': 'error',
     'sfmc/amp-prefer-attribute-value': 'warn',
     'sfmc/amp-no-loop-counter-assign': 'error',
@@ -185,8 +205,8 @@ const ampStrictRules = {
     'sfmc/amp-require-variable-declaration': 'warn',
     'sfmc/amp-function-arity': 'error',
     'sfmc/amp-arg-types': 'error',
-    'sfmc/amp-no-email-excluded-function': ['error', { context: 'email' }],
-    'sfmc/amp-no-deprecated-function': 'error',
+    'sfmc/amp-no-email-excluded-function': 'off',
+    'sfmc/amp-no-deprecated-function': 'warn',
     'sfmc/amp-naming-convention': ['error', { format: 'camelCase' }],
     'sfmc/amp-no-empty-then': 'error',
     'sfmc/amp-require-rowcount-check': 'error',
@@ -230,7 +250,7 @@ const ssjsStrictRules = {
     'sfmc/ssjs-require-hasownproperty': 'error',
     'sfmc/ssjs-require-platform-load-order': 'error',
     'sfmc/ssjs-no-hardcoded-credentials': 'error',
-    'sfmc/ssjs-prefer-platform-load-version': 'error',
+    'sfmc/ssjs-prefer-platform-load-version': 'warn',
     'sfmc/ssjs-no-unavailable-method': 'warn',
     'sfmc/ssjs-prefer-parsejson-safe-arg': 'error',
     'sfmc/ssjs-no-switch-default': 'error',
@@ -240,9 +260,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-no-mcn-unsupported': 'error',
+};
+
+/**
+ * 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-no-mcn-unsupported': '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 +374,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 +432,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 ──────────────────────────────────────────
@@ -386,7 +455,7 @@ Object.assign(plugin.configs, {
         files: ['**/*.ampscript', '**/*.amp'],
         rules: {
             ...ampRecommendedRules,
-            'sfmc/amp-no-unknown-function': ['error', { target: 'next' }],
+            'sfmc/amp-no-mcn-unsupported': 'error',
         },
     },
 
@@ -417,7 +486,7 @@ Object.assign(plugin.configs, {
             files: ['**/*.ampscript', '**/*.amp'],
             rules: {
                 ...ampRecommendedRules,
-                'sfmc/amp-no-unknown-function': ['error', { target: 'next' }],
+                'sfmc/amp-no-mcn-unsupported': 'error',
             },
         },
         {
@@ -450,7 +519,7 @@ Object.assign(plugin.configs, {
             files: ['**/*.html/*.amp'],
             rules: {
                 ...ampRecommendedRules,
-                'sfmc/amp-no-unknown-function': ['error', { target: 'next' }],
+                'sfmc/amp-no-mcn-unsupported': 'error',
             },
         },
         {
@@ -464,6 +533,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 },
+        },
     ],
 
     /**
@@ -477,7 +554,7 @@ Object.assign(plugin.configs, {
             files: ['**/*.ampscript', '**/*.amp'],
             rules: {
                 ...ampStrictRules,
-                'sfmc/amp-no-unknown-function': ['error', { target: 'next' }],
+                'sfmc/amp-no-mcn-unsupported': 'error',
             },
         },
         {
@@ -504,7 +581,7 @@ Object.assign(plugin.configs, {
             files: ['**/*.html/*.amp'],
             rules: {
                 ...ampStrictRules,
-                'sfmc/amp-no-unknown-function': ['error', { target: 'next' }],
+                'sfmc/amp-no-mcn-unsupported': 'error',
             },
         },
         {
@@ -518,7 +595,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 },
                     });
                 }
             },

package/src/rules/amp/no-loop-counter-assign.js

@@ -23,21 +23,21 @@ export default {
         const counterStack = [];
 
         function checkBody(body) {
-            for (const stmt of body) {
-                if (stmt.type === 'SetStatement' && stmt.target) {
+            for (const statement of body) {
+                if (statement.type === 'SetStatement' && statement.target) {
                     const current = counterStack.at(-1);
-                    if (current && stmt.target.value.toLowerCase() === current.toLowerCase()) {
+                    if (current && statement.target.value.toLowerCase() === current.toLowerCase()) {
                         context.report({
-                            node: stmt.target,
+                            node: statement.target,
                             messageId: 'counterAssign',
-                            data: { name: stmt.target.value },
+                            data: { name: statement.target.value },
                         });
                     }
                 }
-                if (stmt.type === 'VarDeclaration') {
+                if (statement.type === 'VarDeclaration') {
                     const current = counterStack.at(-1);
                     if (current) {
-                        for (const v of stmt.variables) {
+                        for (const v of statement.variables) {
                             if (v.value.toLowerCase() === current.toLowerCase()) {
                                 context.report({
                                     node: v,