@platformos/platformos-check-common 0.0.2

package/src/checks/liquid-html-syntax-error/checks/InvalidEchoValue.spec.ts

@@ -0,0 +1,108 @@
+import { expect, describe, it, vi, beforeEach } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('detectInvalidEchoValue', async () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not report when echo value is valid', async () => {
+    const testCases = [
+      `{% echo '123' %}`,
+      `{% echo '123' | upcase %}`,
+      `{{ '123' }}`,
+      `{{ '123' | upcase }}`,
+      `{{ }}`,
+      `{{ echo }}`,
+      `{% liquid echo %}`,
+    ];
+
+    for (const sourceCode of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report when there are no filters provided', async () => {
+    const sourceCode = `{% echo '123' %}`;
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report when there are multiple values (no filters)', async () => {
+    const testCases = [
+      [`{% echo '123' 555 text %}`, "{% echo '123' %}"],
+      [`{% echo "123" 555 text %}`, '{% echo "123" %}'],
+      [`{% echo 123 555 text %}`, '{% echo 123 %}'],
+      [`{% echo true 555 text %}`, '{% echo true %}'],
+      [`{{ '123' 555 text }}`, `{{ '123' }}`],
+      [`{{ "123" 555 text }}`, `{{ "123" }}`],
+      [`{{ 123 555 text }}`, `{{ 123 }}`],
+      [`{{ true 555 text }}`, `{{ true }}`],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should report when there are multiple values (with filters)', async () => {
+    const testCases = [
+      [`{% echo '123' 555 text | upcase %}`, "{% echo '123' | upcase %}"],
+      [`{% echo "123" 555 text | upcase %}`, '{% echo "123" | upcase %}'],
+      [`{% echo 123 555 text | default: 0 %}`, '{% echo 123 | default: 0 %}'],
+      [`{% echo true 555 text | fake-filter: 'yes' %}`, "{% echo true | fake-filter: 'yes' %}"],
+      [`{{ '123' 555 text | upcase }}`, `{{ '123' | upcase }}`],
+      [`{{ "123" 555 text | default: 0 }}`, `{{ "123" | default: 0 }}`],
+      [`{{ 123 555 text | fake-filter: 'yes' }}`, `{{ 123 | fake-filter: 'yes' }}`],
+      [`{{ true 555 text | fake-filter: 'yes' }}`, `{{ true | fake-filter: 'yes' }}`],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should report when there are multiple instances of the error', async () => {
+    const sourceCode = `{% echo zero %} {% echo one two %} {% echo one two %}`;
+
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(2);
+    expect(offenses[0].message).to.equal('Syntax is not supported');
+    expect(offenses[1].message).to.equal('Syntax is not supported');
+
+    const fixed = applyFix(sourceCode, offenses[0]);
+    expect(fixed).to.equal(`{% echo zero %} {% echo one %} {% echo one two %}`);
+
+    const fixed2 = applyFix(sourceCode, offenses[1]);
+    expect(fixed2).to.equal(`{% echo zero %} {% echo one two %} {% echo one %}`);
+  });
+
+  it('should report when there is no value', async () => {
+    const testCases = [
+      [`{% echo | upcase %}`, '{% echo blank %}'],
+      [`{{ | upcase }}`, `{{ blank }}`],
+      [`{% liquid echo | upcase %}`, `{% liquid echo blank %}`],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+});

package/src/checks/liquid-html-syntax-error/checks/InvalidEchoValue.ts

@@ -0,0 +1,74 @@
+import { LiquidTag, LiquidVariableOutput, NodeTypes } from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType } from '../../..';
+import { getValuesInMarkup, INVALID_SYNTAX_MESSAGE } from './utils';
+
+export function detectInvalidEchoValue(
+  node: LiquidTag | LiquidVariableOutput,
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  // We've broken it up into two groups:
+  // 1. The variable(s)
+  // 2. The filter section (non-captured)
+  const ECHO_MARKUP_REGEX = /([^|]*)(?:\s*\|\s*.*)?$/m;
+
+  if (node.type === NodeTypes.LiquidTag && node.name !== 'echo') {
+    return;
+  }
+
+  const markup = node.markup;
+
+  if (
+    typeof markup !== 'string' ||
+    // echo tags and variable outputs without markup are strict-valid:
+    // e.g. {{ }}, {% echo %}, and {% liquid echo %}
+    !markup
+  ) {
+    return;
+  }
+
+  const match = markup.match(ECHO_MARKUP_REGEX);
+  if (!match) {
+    return;
+  }
+
+  const [, echoValue] = match;
+
+  const firstEchoValue = getValuesInMarkup(echoValue).at(0)?.value;
+
+  if (!firstEchoValue) {
+    const startIndex = node.source.indexOf(markup, node.position.start);
+    const endIndex = startIndex + markup.length;
+
+    return {
+      message: INVALID_SYNTAX_MESSAGE,
+      startIndex,
+      endIndex,
+      fix: (corrector) => {
+        corrector.replace(startIndex, endIndex, 'blank');
+      },
+    };
+  }
+
+  const removalIndices = (source: string, startingIndex: number) => {
+    const offset = source.indexOf(markup, startingIndex);
+
+    return {
+      startIndex: offset + firstEchoValue.length,
+      endIndex: offset + echoValue.trimEnd().length,
+    };
+  };
+
+  const { startIndex, endIndex } = removalIndices(node.source, node.position.start);
+
+  if (endIndex <= startIndex) {
+    return;
+  }
+
+  return {
+    message: INVALID_SYNTAX_MESSAGE,
+    startIndex,
+    endIndex,
+    fix: (corrector) => {
+      corrector.replace(startIndex, endIndex, '');
+    },
+  };
+}

package/src/checks/liquid-html-syntax-error/checks/InvalidFilterName.spec.ts

@@ -0,0 +1,223 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck, applyFix } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('Module: InvalidFilterName', () => {
+  describe('Alphanumeric and underscore trailing characters', () => {
+    it('should not report on filters with alphanumeric trailing characters', async () => {
+      const sourceCode = `{{ 'HELLO' | append123: 'world' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on filters with underscore trailing characters', async () => {
+      const sourceCode = `{{ 'HELLO' | append_test }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('Valid filters', () => {
+    it('should not report on valid filter names', async () => {
+      const sourceCode = `{{ 'hello' | append: 'world' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on unknown filters (handled by UnknownFilter check)', async () => {
+      const sourceCode = `{{ 'hello' | completely_unknown_filter: 'world' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('Special characters after filter name', () => {
+    it('should detect and fix append with trailing @ character', async () => {
+      const sourceCode = `{{ 'HELLO' | append@ }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append');
+      expect(fixedCode).not.toContain('append@');
+    });
+
+    it('should detect and fix filter with space followed by characters', async () => {
+      const sourceCode = `{{ 'HELLO' | append me: 'world' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append:');
+      expect(fixedCode).not.toContain('append me:');
+    });
+  });
+
+  describe('Filter combinations and chains', () => {
+    it('should handle normal filter followed by filter with special characters', async () => {
+      const sourceCode = `{{ 'test' | downcase | append@: 'world' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'test' | downcase | append: 'world' }}`);
+    });
+
+    it('should handle filter with special characters followed by normal filter', async () => {
+      const sourceCode = `{{ 'test' | append!: 'hello' | upcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '!'");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'test' | append: 'hello' | upcase }}`);
+    });
+
+    it('should handle two filters with special characters in a row', async () => {
+      const sourceCode = `{{ 'test' | append@: 'hello' | upcase# }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[1].message).toContain("Filter 'upcase' has trailing characters '#'");
+
+      expect(offenses[0].fix).toBeDefined();
+      expect(offenses[1].fix).toBeDefined();
+
+      // Test individual fixes
+      const firstFixed = applyFix(sourceCode, offenses[0]);
+      expect(firstFixed).toBe(`{{ 'test' | append: 'hello' | upcase# }}`);
+
+      const secondFixed = applyFix(sourceCode, offenses[1]);
+      expect(secondFixed).toBe(`{{ 'test' | append@: 'hello' | upcase }}`);
+    });
+
+    it('should handle filter with space and characters followed by normal filter', async () => {
+      const sourceCode = `{{ 'test' | append xyz: 'hello' | upcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters ' xyz'");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'test' | append: 'hello' | upcase }}`);
+    });
+  });
+
+  describe('Assign tag filters', () => {
+    it('should detect and fix assign with trailing @ character', async () => {
+      const sourceCode = `{% assign foo = 'HELLO' | append@ %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append');
+      expect(fixedCode).not.toContain('append@');
+    });
+
+    it('should detect and fix assign with space followed by characters', async () => {
+      const sourceCode = `{% assign bar = 'HELLO' | append me: 'world' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append:');
+      expect(fixedCode).not.toContain('append me:');
+    });
+
+    it('should handle assign with multiple filters with special characters', async () => {
+      const sourceCode = `{% assign baz = 'test' | append@: 'hello' | upcase# %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[1].message).toContain("Filter 'upcase' has trailing characters '#'");
+
+      expect(offenses[0].fix).toBeDefined();
+      expect(offenses[1].fix).toBeDefined();
+    });
+
+    it('should not report on valid assign filters', async () => {
+      const sourceCode = `{% assign valid = 'hello' | append: 'world' | upcase %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('Echo tag filters', () => {
+    it('should detect and fix echo with trailing @ character', async () => {
+      const sourceCode = `{% echo 'HELLO' | append@ %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append');
+      expect(fixedCode).not.toContain('append@');
+    });
+
+    it('should detect and fix echo with space followed by characters', async () => {
+      const sourceCode = `{% echo 'HELLO' | append me: 'world' %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters");
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toContain('append:');
+      expect(fixedCode).not.toContain('append me:');
+    });
+
+    it('should handle echo with multiple filters with special characters', async () => {
+      const sourceCode = `{% echo 'test' | append@: 'hello' | upcase# %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[1].message).toContain("Filter 'upcase' has trailing characters '#'");
+
+      expect(offenses[0].fix).toBeDefined();
+      expect(offenses[1].fix).toBeDefined();
+    });
+
+    it('should not report on valid echo filters', async () => {
+      const sourceCode = `{% echo 'hello' | append: 'world' | upcase %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('Liquid tag filters', () => {
+    it('should detect and fix assign in liquid tag with trailing characters', async () => {
+      const sourceCode = `{% liquid
+        assign foo = 'test' | append@: 'hello'
+      %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[0].fix).toBeDefined();
+    });
+
+    it('should detect and fix echo in liquid tag with trailing characters', async () => {
+      const sourceCode = `{% liquid
+        echo 'test' | append@: 'hello'
+      %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain("Filter 'append' has trailing characters '@'");
+      expect(offenses[0].fix).toBeDefined();
+    });
+  });
+});

package/src/checks/liquid-html-syntax-error/checks/InvalidFilterName.ts

@@ -0,0 +1,92 @@
+import {
+  LiquidVariableOutput,
+  LiquidTag,
+  NodeTypes,
+  NamedTags,
+} from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType, Context, FilterEntry } from '../../..';
+import { INVALID_SYNTAX_MESSAGE } from './utils';
+
+export async function detectInvalidFilterName(
+  node: LiquidVariableOutput | LiquidTag,
+  filters: FilterEntry[] | undefined,
+): Promise<Problem<SourceCodeType.LiquidHtml>[]> {
+  if (!filters) {
+    return [];
+  }
+
+  if (node.type === NodeTypes.LiquidVariableOutput) {
+    if (typeof node.markup !== 'string') {
+      return [];
+    }
+    return detectInvalidFilterNameInMarkup(node, node.markup, filters);
+  }
+
+  if (node.type === NodeTypes.LiquidTag) {
+    if (node.name === NamedTags.echo && typeof node.markup !== 'string') {
+      return [];
+    }
+    if (node.name === NamedTags.assign && typeof node.markup !== 'string') {
+      return [];
+    }
+    if (
+      typeof node.markup === 'string' &&
+      (node.name === NamedTags.echo || node.name === NamedTags.assign)
+    ) {
+      return detectInvalidFilterNameInMarkup(node, node.markup, filters);
+    }
+  }
+
+  return [];
+}
+
+async function detectInvalidFilterNameInMarkup(
+  node: LiquidVariableOutput | LiquidTag,
+  markup: string,
+  filters: FilterEntry[],
+): Promise<Problem<SourceCodeType.LiquidHtml>[]> {
+  const knownFilters = filters;
+  const trimmedMarkup = markup.trim();
+  const problems: Problem<SourceCodeType.LiquidHtml>[] = [];
+
+  const filterPattern = /\|\s*([a-zA-Z][a-zA-Z0-9_]*)/g;
+  const matches = Array.from(trimmedMarkup.matchAll(filterPattern));
+
+  for (const match of matches) {
+    const filterName = match[1];
+
+    if (!knownFilters.some((filter) => filter.name === filterName)) {
+      continue;
+    }
+
+    const filterEndIndex = match.index! + match[0].length;
+    const afterFilter = trimmedMarkup.slice(filterEndIndex);
+
+    // This regex finds invalid trailing characters after a filter name using lookaheads:
+    // 1. Skip valid syntax like ": parameter" or "| nextfilter"
+    // 2. Capture any junk characters that shouldn't be there
+    // 3. Stop before valid boundaries like colons or pipes
+    // e.g. "upcase xyz" finds "xyz", but "upcase | downcase" is ignored as valid
+    const invalidSegment = afterFilter.match(
+      /^(?!\s*(?::|$|\|\s*[a-zA-Z]|\|\s*\||\s*\|\s*(?:[}%]|$)))([^:|]+?)(?=\s*(?::|$|\|))/,
+    )?.[1];
+    if (!invalidSegment) {
+      continue;
+    }
+
+    const markupStartInSource = node.source.indexOf(markup, node.position.start);
+    const trailingStartInSource = markupStartInSource + filterEndIndex;
+    const trailingEndInSource = trailingStartInSource + invalidSegment.length;
+
+    problems.push({
+      message: `${INVALID_SYNTAX_MESSAGE} Filter '${filterName}' has trailing characters '${invalidSegment}' that should be removed.`,
+      startIndex: trailingStartInSource,
+      endIndex: trailingEndInSource,
+      fix: (corrector) => {
+        corrector.replace(trailingStartInSource, trailingEndInSource, '');
+      },
+    });
+  }
+
+  return problems;
+}

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopArguments.spec.ts

@@ -0,0 +1,145 @@
+import { expect, describe, it } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('detectInvalidLoopArguments', async () => {
+  it('should not report when args are valid', async () => {
+    const testCases = [
+      `{% for i in array reversed %}{% endfor %}`,
+      `{% for i in array reversed offset: 1 %}{% endfor %}`,
+      `{% tablerow x in array limit: 10 %}{% endtablerow %}`,
+      `{% tablerow x in array cols: 2 limit: 10 %}{% endtablerow %}`,
+    ];
+
+    for (const sourceCode of testCases) {
+      const offenses = await testCheck(sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report when invalid args are found', async () => {
+    const testCases = [
+      [
+        `{% for i in array limit1: 10 %}{% endfor %}`,
+        '{% for i in array  %}{% endfor %}',
+        'limit1: 10',
+      ],
+      [
+        `{% for i in array !! range: (1..2) %}{% endfor %}`,
+        '{% for i in array  %}{% endfor %}',
+        '!!, range: (1..2)',
+      ],
+      [
+        `{% tablerow i in (1..10) limit1: 10 %}{{ i }}{% endtablerow %}`,
+        '{% tablerow i in (1..10)  %}{{ i }}{% endtablerow %}',
+        'limit1: 10',
+      ],
+    ];
+
+    for (const [sourceCode, expected, invalidArguments] of testCases) {
+      const offenses = await testCheck(sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).toEqual(
+        expect.stringContaining(`Invalid/Unknown arguments: ${invalidArguments}`),
+      );
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should report when positional args are found after named/invalid args', async () => {
+    const testCases = [
+      [
+        `{% for i in array limit: 10 reversed %}{% endfor %}`,
+        '{% for i in array limit: 10 %}{% endfor %}',
+        'reversed',
+      ],
+      [
+        `{% for i in array reversed limit: 10 invalid %}{% endfor %}`,
+        '{% for i in array reversed limit: 10 %}{% endfor %}',
+        'invalid',
+      ],
+      [
+        `{% for i in array !! reversed limit: 10 invalid %}{% endfor %}`,
+        '{% for i in array limit: 10 %}{% endfor %}',
+        '!!, reversed, invalid',
+      ],
+      [
+        `{% for i in array reversed: (1..2) %}{% endfor %}`,
+        '{% for i in array  %}{% endfor %}',
+        'reversed: (1..2)',
+      ],
+    ];
+
+    for (const [sourceCode, expected, invalidArguments] of testCases) {
+      const offenses = await testCheck(sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).toEqual(
+        expect.stringContaining(`Invalid/Unknown arguments: ${invalidArguments}`),
+      );
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should report when there are multiple instances of the error', async () => {
+    const sourceCode = `{% for i in array reversed limit: 10 invalid %}{% endfor %} {% tablerow x in array cols: 2 limit: 10 invalid %}{% endtablerow %}`;
+
+    const offenses = await testCheck(sourceCode);
+    expect(offenses).to.have.length(2);
+    for (const offense of offenses) {
+      expect(offense.message).toEqual(
+        expect.stringContaining(`Invalid/Unknown arguments: invalid`),
+      );
+    }
+
+    const fixed = applyFix(sourceCode, offenses[0]);
+    expect(fixed).to.equal(
+      '{% for i in array reversed limit: 10 %}{% endfor %} {% tablerow x in array cols: 2 limit: 10 invalid %}{% endtablerow %}',
+    );
+
+    const fixed2 = applyFix(sourceCode, offenses[1]);
+    expect(fixed2).to.equal(
+      '{% for i in array reversed limit: 10 invalid %}{% endfor %} {% tablerow x in array cols: 2 limit: 10 %}{% endtablerow %}',
+    );
+  });
+});
+
+function testCheck(sourceCode: string) {
+  return runLiquidCheck(LiquidHTMLSyntaxError, sourceCode, undefined, {
+    themeDocset: {
+      graphQL: async () => null,
+      tags: () =>
+        Promise.resolve([
+          {
+            name: 'for',
+            parameters: [
+              {
+                name: 'reversed',
+                positional: true,
+                description: '...',
+                required: false,
+                types: [],
+              },
+              { name: 'limit', positional: false, description: '...', required: false, types: [] },
+              { name: 'offset', positional: false, description: '...', required: false, types: [] },
+            ],
+          },
+          {
+            name: 'tablerow',
+            parameters: [
+              { name: 'cols', positional: false, description: '...', required: false, types: [] },
+              { name: 'limit', positional: false, description: '...', required: false, types: [] },
+              { name: 'offset', positional: false, description: '...', required: false, types: [] },
+            ],
+          },
+        ]),
+      filters: () => Promise.resolve([]),
+      objects: () => Promise.resolve([]),
+      liquidDrops: () => Promise.resolve([]),
+      systemTranslations: () => Promise.resolve({}),
+    },
+  });
+}