@ttsc/lint 0.30.3 → 0.31.0

package/linthost/unicorn_better_regex_skips_unicode_flag_literals_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestUnicornBetterRegexSkipsUnicodeFlagLiterals verifies the rule never
+// touches a literal carrying the `u` or `v` flag, even when its body is
+// otherwise optimizable.
+//
+// The historical regexp-tree issue documents escaped-character parsing failures
+// under `u` (DmitrySoshnikov/regexp-tree#162). This Go rule returns early on u/v
+// literals before its optimizer. These zero-findings probes observe the exclusions:
+// `[0-9]` collapses to `\d` without a flag, so the `/u` and `/v` twins prove
+// the expected distinction, and the alternation and character-class
+// bodies under the `u` flag provide two more excluded shapes. They do not observe optimizer calls.
+//
+//  1. Lint each `u` / `v` literal, including bodies that would optimize.
+//  2. Assert no diagnostic fires.
+//
+// @evidence contracts/testing.md#behavioral-verification assertRuleSkipsSource requires zero findings for the five authored Unicode-mode literals; source inspection separately identifies the early flag guard.
+// @evidence contracts/testing.md#independent-expectations The authored u/v/gu fixtures independently specify zero findings without reading optimizer output or certifying upstream parity.
+// @evidence contracts/testing.md#distinguishing-cases The optimizable digit class is clean with u/v/gu flags, and `u`-flagged alternation and character-class bodies that the optimizer would otherwise rewrite stay clean; the flagless digit class positive is the corpus fixture unicorn-better-regex.ts.
+// @evidence contracts/testing.md#execution-ownership All five excluded sources execute in this named Go unit entry; the shared Go process runs owning operations without installing a consumer, building a native artifact or launching a product host.
+func TestUnicornBetterRegexSkipsUnicodeFlagLiterals(t *testing.T) {
+  sources := []string{
+    "const foo = /[0-9]/u;\n",
+    "const foo = /[0-9]/v;\n",
+    "const foo = /[0-9]/gu;\n",
+    "const foo = /(\\s|\\.|@|_|-)/u;\n",
+    "const foo = /[\\s.@_-]/u;\n",
+  }
+  for _, source := range sources {
+    assertRuleSkipsSource(t, unicornBetterRegexRuleName, source)
+  }
+}

package/linthost/unicorn_better_regex_sort_character_classes_option_test.go

@@ -0,0 +1,39 @@
+package linthost
+
+import "testing"
+
+// TestUnicornBetterRegexSortCharacterClassesOption verifies the
+// `sortCharacterClasses` option gates only the class range-merge/sort
+// transform, leaving the shorthand rewrites intact.
+//
+// Setting the option to `false` blacklists the Go optimizer's named
+// `charClassClassrangesMerge`, so a purely reordering optimization
+// (`[GgHhIi...]`) is suppressed while a shorthand that also shortens the class
+// (`[a0-9b]` -> `[a\db]`) still fires. The two cases under the same option pin
+// both halves: the disabled transform stays disabled, and the unrelated
+// transforms keep running.
+//
+//  1. With the option off, assert `[a0-9b]` still gets its `\d` shorthand.
+//  2. With the option off, assert a sort-only class is left unchanged.
+//
+// @evidence contracts/testing.md#behavioral-verification the option-aware fix and no-finding helpers verify disabling class sorting does not disable digit shorthand rewriting.
+// @evidence contracts/testing.md#independent-expectations The authored [a\db] fixed output and unchanged class specify the two option outcomes independently of the Go optimizer, without claiming upstream execution.
+// @evidence contracts/testing.md#distinguishing-cases With the same sortCharacterClasses:false option, digit shortening still acts while pure class rearrangement does not; TestUnicornBetterRegex owns default sorting.
+// @evidence contracts/testing.md#execution-ownership Both option-controlled sources execute in this named Go unit entry; the shared Go process runs owning operations without installing a consumer, building a native artifact or launching a product host.
+func TestUnicornBetterRegexSortCharacterClassesOption(t *testing.T) {
+  const disableSort = `{"sortCharacterClasses": false}`
+
+  assertFixSnapshotWithOptions(
+    t,
+    unicornBetterRegexRuleName,
+    "const foo = /[a0-9b]/;\n",
+    disableSort,
+    "const foo = /[a\\db]/;\n",
+  )
+  assertRuleSkipsSourceWithOptions(
+    t,
+    unicornBetterRegexRuleName,
+    "const foo = /[GgHhIiå.Z:a-f\"0-8%A*ä]/;\n",
+    disableSort,
+  )
+}

package/linthost/unicorn_better_regex_test.go

@@ -0,0 +1,44 @@
+package linthost
+
+import "testing"
+
+const unicornBetterRegexRuleName = "unicorn/better-regex"
+
+// TestUnicornBetterRegex verifies fifteen authored regex literal rewrites.
+//
+// The independent input/output strings pin character-class shorthands,
+// complements, flag order, class ordering and quantifier merging. Actual
+// findings and applied fixes must produce the complete expected declaration;
+// this corpus does not prove global shortest form or upstream version parity.
+//
+//  1. Lint each declaration through the actual fix applier.
+//  2. Assert the rewritten source equals the independently authored literal.
+//
+// @evidence contracts/testing.md#behavioral-verification assertFixSnapshot verifies fifteen literal regex rewrites, including digit/word complements, flag order, class sorting, whitespace quantifiers and the single-character class escape.
+// @evidence contracts/testing.md#independent-expectations Each input/output pair supplies an independently authored full-source oracle for the declared transformation; equality detects token differences without proving all-input semantic equivalence or upstream provenance.
+// @evidence contracts/testing.md#distinguishing-cases Positive pairs retain surrounding declaration text; the negated [^*] class stays a class while [*] becomes an escaped literal. TestUnicornBetterRegexLeavesOptimalLiterals owns the adjacent canonical no-finding corpus.
+// @evidence contracts/testing.md#execution-ownership The table loops in this Go unit entry; failures retain the input/output fixture printed by assertFixSnapshot; the shared Go process runs owning operations without installing a consumer, building a native artifact or launching a product host.
+func TestUnicornBetterRegex(t *testing.T) {
+  cases := []struct{ input, output string }{
+    {"const foo = /[0-9]/;\n", "const foo = /\\d/;\n"},
+    {"const foo = /[^0-9]/;\n", "const foo = /\\D/;\n"},
+    {"const foo = /\\w/ig;\n", "const foo = /\\w/gi;\n"},
+    {"const foo = /[A-Za-z0-9_]/;\n", "const foo = /\\w/;\n"},
+    {"const foo = /[A-Za-z\\d_]/;\n", "const foo = /\\w/;\n"},
+    {"const foo = /[^A-Za-z0-9_]/;\n", "const foo = /\\W/;\n"},
+    {"const foo = /[a-z0-9_]/i;\n", "const foo = /\\w/i;\n"},
+    {"const foo = /[^a-z\\d_]/ig;\n", "const foo = /\\W/gi;\n"},
+    {"const foo = /[a-z0-9_]/;\n", "const foo = /[\\d_a-z]/;\n"},
+    {"const foo = /[A-Za-z0-9_]+[0-9]?\\.[A-Za-z0-9_]*/;\n", "const foo = /\\w+\\d?\\.\\w*/;\n"},
+    {"const foo = /^by @([a-zA-Z0-9-]+)/;\n", "const foo = /^by @([\\dA-Za-z-]+)/;\n"},
+    {"const foo = /^[a-z][a-z0-9\\-]{5,29}$/;\n", "const foo = /^[a-z][\\da-z\\-]{5,29}$/;\n"},
+    {"const foo = /\\s?\\s?\\s?/;\n", "const foo = /\\s{0,3}/;\n"},
+    {"const foo = /[GgHhIiå.Z:a-f\"0-8%A*ä]/;\n", "const foo = /[\"%*.0-8:AG-IZa-iäå]/;\n"},
+    // Single-char class collapses to the escaped char; the adjacent negated
+    // single-char class `[^*]` is the negative twin — it must stay a class.
+    {"const foo = /^[^*]*[*]?$/;\n", "const foo = /^[^*]*\\*?$/;\n"},
+  }
+  for _, tc := range cases {
+    assertFixSnapshot(t, unicornBetterRegexRuleName, tc.input, tc.output)
+  }
+}

package/linthost/unicorn_bigint_literal_requires_an_exact_integer_value_test.go

@@ -0,0 +1,34 @@
+package linthost
+
+import "testing"
+
+// TestUnicornBigintLiteralRequiresAnExactIntegerValue verifies numeric BigInt advice requires an exactly represented integer.
+//
+// Fractional numbers throw during BigInt conversion. Unsafe decimal integers can already be rounded before conversion, unlike bigint source literals.
+//
+// 1. Run the owning rule on the authored load-bearing arguments.
+// 2. Require zero findings on those inputs.
+// 3. Preserve report-only diagnostics for the adjacent ordinary idioms.
+//
+// @evidence contracts/testing.md#behavioral-verification Engine runs unicorn/prefer-bigint-literals; zero-finding negatives distinguish the named argument boundary and report-only positives require activation without automatic edits.
+// @evidence contracts/testing.md#independent-expectations Fractional numbers throw during BigInt conversion. Unsafe decimal integers can already be rounded before conversion, unlike bigint source literals.
+// @evidence contracts/testing.md#distinguishing-cases Fractions and unsafe Number operands are excluded; exponent Number syntax and arbitrary-precision or signed decimal integer strings retain report-only advice.
+// @evidence contracts/testing.md#execution-ownership This discoverable Go unit uses the owning Engine and shared finding helpers in process without installation or a native host.
+func TestUnicornBigintLiteralRequiresAnExactIntegerValue(t *testing.T) {
+  for _, source := range []string{
+    "const value = BigInt(1.5);",
+    "const value = BigInt(9007199254740993);",
+    "const value = BigInt(9007199254740992);",
+    "const value = BigInt('1.5');",
+  } {
+    t.Run(source, func(t *testing.T) { assertRuleSkipsSource(t, "unicorn/prefer-bigint-literals", source) })
+  }
+  for _, source := range []string{
+    "const value = BigInt(1);",
+    "const value = BigInt(1e3);",
+    "const value = BigInt('9007199254740993');",
+    "const value = BigInt('+01');",
+  } {
+    t.Run(source, func(t *testing.T) { assertReportOnlySnapshot(t, "unicorn/prefer-bigint-literals", source) })
+  }
+}

package/linthost/unicorn_consistent_destructuring_jsx_tag_names_are_exempt_test.go

@@ -0,0 +1,53 @@
+package linthost
+
+import (
+  "strings"
+  "testing"
+)
+
+// TestUnicornConsistentDestructuringJsxTagNamesAreExempt verifies JSX
+// element tags never report while JSX expression containers still do.
+//
+// TypeScript-Go represents the member tag as a PropertyAccessExpression.
+// The rule explicitly excludes JSX tag positions while admitting expression
+// containers. The source below checks that distinction for the same Lib.Item
+// spelling; it does not apply a suggestion or execute/render either form.
+//
+//  1. Destructure `Item` from `Lib` in a TSX file.
+//  2. Use `Lib.Item` as an element tag and inside a JSX attribute expression.
+//  3. Assert only the attribute expression read is reported.
+//
+// @evidence contracts/testing.md#behavioral-verification runRuleFindingsSnapshotFile checks exactly one attribute-expression member range and its literal suggestion title, detecting JSX tags misclassified as ordinary property reads.
+// @evidence contracts/testing.md#independent-expectations The authored JSX-tag exclusion and expression-read expectation establish the independently located marker member and literal Item suggestion title; replacement application is not observed.
+// @evidence contracts/testing.md#distinguishing-cases The same Lib.Item spelling is clean as a JSX tag but reports inside marker={...}; the tag-position distinction is the decision boundary.
+// @evidence contracts/testing.md#execution-ownership TestUnicornConsistentDestructuringJsxTagNamesAreExempt owns this authored source matrix as one discoverable Go unit entry. Its TSX fixture exercises the owning checker-backed engine in the shared Go process; failure output identifies the member range or suggestion payload. No installed consumer, native build or child product host runs.
+func TestUnicornConsistentDestructuringJsxTagNamesAreExempt(t *testing.T) {
+  source := `declare global {
+  namespace JSX {
+    interface Element {}
+    interface IntrinsicElements {
+      section: {marker?: unknown};
+    }
+  }
+}
+export const Lib = {
+  Item: (): JSX.Element => ({}),
+};
+const {Item} = Lib;
+void Item;
+export const tag = <Lib.Item />;
+export const attribute = <section marker={Lib.Item} />;
+`
+  _, _, findings := runRuleFindingsSnapshotFile(t, "unicorn/consistent-destructuring", "main.tsx", source, nil)
+  if len(findings) != 1 {
+    t.Fatalf("findings = %d, want 1: %+v", len(findings), findings)
+  }
+  finding := findings[0]
+  start := strings.Index(source, "marker={Lib.Item}") + len("marker={")
+  if finding.Pos != start || finding.End != start+len("Lib.Item") {
+    t.Fatalf("finding range = [%d, %d), want [%d, %d)", finding.Pos, finding.End, start, start+len("Lib.Item"))
+  }
+  if len(finding.Suggestions) != 1 || finding.Suggestions[0].Title != "Replace `Lib.Item` with destructured property `Item`." {
+    t.Fatalf("suggestion = %+v", finding.Suggestions)
+  }
+}

package/linthost/unicorn_consistent_destructuring_skips_valid_forms_test.go

@@ -0,0 +1,221 @@
+package linthost
+
+import "testing"
+
+// TestRuleCorpusUnicornConsistentDestructuringSkipsValidForms verifies the
+// the authored non-reporting matrix: its writable, unstable, differently
+// scoped and syntax-exempt forms must produce zero findings.
+//
+// Over-matching is the failure mode this rule invites — a write target
+// mistaken for a read, a shadowed root treated as the tracked one, or a
+// type-narrowing `in` guard ignored each turn a valid file noisy. Every
+// scenario supplies a direct accepted-form expectation, including
+// destructuring-assignment slots for the left-hand-side arm. The test does not
+// execute an upstream oracle or certify an exhaustive upstream population.
+//
+//  1. Enable unicorn/consistent-destructuring on one type-clean source that
+//     stacks the authored accepted forms.
+//  2. Run the checker-backed snapshot path.
+//  3. Assert the rule reports nothing.
+//
+// @evidence contracts/testing.md#behavioral-verification Checker-backed zero-finding assertions detect invalid suggestions on writable, unstable or differently scoped bindings.
+// @evidence contracts/testing.md#independent-expectations The authored zero expectation follows the selected const binding, write safety, lexical scope and guard/receiver policies; it is not computed from returned findings or an upstream execution.
+// @evidence contracts/testing.md#distinguishing-cases Calls/new/tagged/computed members, writes/destructuring targets, mutable roots/bindings, shadows, guards, early reads, default/nested/rest forms and different this scopes occupy separate declarations inside the one authored clean source.
+// @evidence contracts/testing.md#execution-ownership TestRuleCorpusUnicornConsistentDestructuringSkipsValidForms owns this authored source matrix as one discoverable Go unit entry. Its authored matrix exercises the owning checker-backed engine in the shared Go process; the zero-finding helper retains source identity on failure. No installed consumer, native build or child product host runs.
+func TestRuleCorpusUnicornConsistentDestructuringSkipsValidForms(t *testing.T) {
+  source := `declare const sibling: { a: number; b: number };
+declare const invoked: { a: () => void };
+declare const constructed: { A: new () => object };
+declare const tagged: { tag: (parts: TemplateStringsArray) => string };
+declare const computed: Record<string, number>;
+declare const erased: { a?: number };
+declare const updated: { a: number };
+declare const written: { a: number };
+declare const patterned: { a: number };
+declare const restTarget: { a: number[] };
+declare const looped: { a: number };
+declare const keyed: { k: string };
+declare const relet: { a: number };
+declare let reassigned: { a: number };
+declare let crossWritten: { a: number };
+declare const crossMember: { a: number };
+declare const shadowedRoot: { a: number };
+declare const shadowedBinding: { a: number };
+declare const guarded: { a: string; b?: number };
+declare const late: { a: number };
+declare const sameStatement: { a: number };
+declare const stringKey: { a: number };
+declare const defaultKey: { a?: number };
+declare const nested: { a: { b: number } };
+declare const restRead: { a: number; c: number };
+declare const viaMember: { bar: { a: number } };
+declare function viaCall(): { a: number };
+
+const {a: siblingA} = sibling;
+void [siblingA, sibling.b];
+
+const {a: invokedA} = invoked;
+void invokedA;
+invoked.a();
+
+const {A: constructedA} = constructed;
+void constructedA;
+void new constructed.A();
+
+const {tag} = tagged;
+void tag;
+void tagged.tag` + "`template`" + `;
+
+const {a: computedA} = computed;
+void computedA;
+void computed["a"];
+
+const {a: erasedA} = erased;
+void erasedA;
+delete erased.a;
+void erased.a;
+
+const {a: updatedA} = updated;
+void updatedA;
+updated.a++;
+--updated.a;
+updated.a += 1;
+void updated.a;
+
+const {a: writtenA} = written;
+void writtenA;
+written.a = 1;
+void written.a;
+
+const {a: patternedA} = patterned;
+void patternedA;
+[patterned.a] = [1];
+({a: patterned.a} = {a: 2});
+void patterned.a;
+
+const {a: restTargetA} = restTarget;
+void restTargetA;
+[...restTarget.a] = [3];
+void restTarget.a;
+
+const {a: loopedA} = looped;
+void loopedA;
+for (looped.a of [4]) {}
+for ([looped.a] of [[5]]) {}
+void looped.a;
+
+const {k: keyedK} = keyed;
+void keyedK;
+for (keyed.k in {x: 6}) {}
+void keyed.k;
+
+let {a: reletA} = relet;
+void [reletA, relet.a];
+
+const {a: reassignedA} = reassigned;
+void reassignedA;
+reassigned = {a: 7};
+void reassigned.a;
+
+const {a: crossWrittenA} = crossWritten;
+void crossWrittenA;
+function writeRoot(): void {
+  crossWritten = {a: 8};
+}
+void [writeRoot, crossWritten.a];
+
+const {a: crossMemberA} = crossMember;
+void crossMemberA;
+function writeMember(): void {
+  crossMember.a = 9;
+}
+void [writeMember, crossMember.a];
+
+const {a: shadowedRootA} = shadowedRoot;
+void shadowedRootA;
+{
+  const shadowedRoot = {a: 10};
+  void shadowedRoot.a;
+}
+
+const {a: shadowedBindingA} = shadowedBinding;
+void shadowedBindingA;
+{
+  const shadowedBindingA = 11;
+  void [shadowedBindingA, shadowedBinding.a];
+}
+
+const {a: guardedA, b: guardedB} = guarded;
+void [guardedA, guardedB];
+if ('b' in guarded) {
+  void guarded.b;
+}
+if ('b' in guarded && guardedA) {
+  void guarded.b;
+}
+const guardedLogical = 'b' in guarded && guarded.b;
+void guardedLogical;
+const guardedTernary = 'b' in guarded ? guarded.b : undefined;
+void guardedTernary;
+if ('b' in guarded) {
+  const guardedArrow = () => guarded.b;
+  void guardedArrow;
+  const guardedExpression = function (): number | undefined {
+    return guarded.b;
+  };
+  void guardedExpression;
+  const guardedObject = {
+    read(): number | undefined {
+      return guarded.b;
+    },
+  };
+  void guardedObject;
+}
+
+void late.a;
+const {a: lateA} = late;
+void lateA;
+
+const sameStatementValue = sameStatement.a, {a: sameStatementA} = sameStatement;
+void [sameStatementValue, sameStatementA];
+
+const {'a': stringKeyA} = stringKey;
+void [stringKeyA, stringKey.a];
+
+const {a: defaultKeyA = 12} = defaultKey;
+void [defaultKeyA, defaultKey.a];
+
+const {a: {b: nestedB}} = nested;
+void [nestedB, nested.a];
+
+const {a: restReadA, ...restReadRest} = restRead;
+void [restReadA, restReadRest, restRead.c];
+
+const {a: viaMemberA} = viaMember.bar;
+void [viaMemberA, viaMember.bar.a];
+
+const {a: viaCallA} = viaCall();
+void [viaCallA, viaCall().a];
+
+class OwnThis {
+  x = 1;
+  destructure(): void {
+    const {x} = this;
+    void x;
+  }
+  read(): number {
+    return this.x;
+  }
+  boundThis(): number {
+    const {x} = this;
+    void x;
+    const inner = function (this: OwnThis): number {
+      return this.x;
+    };
+    return inner.call(this);
+  }
+}
+void OwnThis;
+`
+  assertRuleSkipsSource(t, "unicorn/consistent-destructuring", source)
+}

package/linthost/unicorn_consistent_destructuring_suggestion_is_opt_in_and_idempotent_test.go

@@ -0,0 +1,54 @@
+package linthost
+
+import "testing"
+
+// TestUnicornConsistentDestructuringSuggestionIsOptInAndIdempotent verifies
+// the replacement ships as an editor suggestion, never as an autofix, and
+// that accepting it converges.
+//
+// The actual finding has a suggestion and no automatic fix. This unit checks
+// the in-memory automatic edit pass leaves the source untouched, then explicitly
+// applies the suggestion edits and re-lints the result; no CLI or LSP request runs.
+//
+//  1. Report `foo.a` after `const {a} = foo` and capture the finding.
+//  2. Assert the automatic-fix path applies zero edits.
+//  3. Apply the suggestion edit, assert the exact rewritten source, and
+//     re-run the rule on it to prove convergence.
+//
+// @evidence contracts/testing.md#behavioral-verification Exact suggestion title/range/text, unchanged automatic-fix result and independently authored rewritten source distinguish accidental autofix or incorrect variable substitution; a rerun checks convergence.
+// @evidence contracts/testing.md#independent-expectations The public suggestion-only contract and authored foo.a-to-a binding identity establish exact source and edit expectations without using emitted source as the oracle.
+// @evidence contracts/testing.md#distinguishing-cases The original read reports but automatic fixing is forbidden; accepting its single suggestion produces the literal clean a reference.
+// @evidence contracts/testing.md#execution-ownership TestUnicornConsistentDestructuringSuggestionIsOptInAndIdempotent owns this authored source matrix as one discoverable Go unit entry. Its authored source exercises the owning checker-backed engine and in-process edit applier, preserving edit/source identity on failure. No installed consumer, native build or child product host runs.
+func TestUnicornConsistentDestructuringSuggestionIsOptInAndIdempotent(t *testing.T) {
+  source := "declare const foo: { a: number };\nconst {a} = foo;\nvoid foo.a;\n"
+  _, _, findings := runRuleFindingsSnapshot(t, "unicorn/consistent-destructuring", source, nil)
+  if len(findings) != 1 {
+    t.Fatalf("findings = %d, want 1: %+v", len(findings), findings)
+  }
+  finding := findings[0]
+  if len(finding.Fix) != 0 || len(finding.Suggestions) != 1 {
+    t.Fatalf("fixes = %d, suggestions = %d", len(finding.Fix), len(finding.Suggestions))
+  }
+  suggestion := finding.Suggestions[0]
+  if suggestion.Title != "Replace `foo.a` with destructured property `a`." || len(suggestion.Edits) != 1 {
+    t.Fatalf("suggestion = %+v", suggestion)
+  }
+  prefix := "declare const foo: { a: number };\nconst {a} = foo;\nvoid "
+  edit := suggestion.Edits[0]
+  if edit.Pos != len(prefix) || edit.End != edit.Pos+len("foo.a") || edit.Text != "a" {
+    t.Fatalf("edit = %+v", edit)
+  }
+  automatic, applied := applyFindingFixesToText(source, findings)
+  if applied != 0 || automatic != source {
+    t.Fatalf("automatic edits changed source: applied=%d source=%q", applied, automatic)
+  }
+  rewritten, applied := applyFindingFixesToText(source, []*Finding{{Fix: suggestion.Edits}})
+  expected := "declare const foo: { a: number };\nconst {a} = foo;\nvoid a;\n"
+  if applied != 1 || rewritten != expected {
+    t.Fatalf("suggestion result: applied=%d\nwant %q\ngot  %q", applied, expected, rewritten)
+  }
+  _, _, converged := runRuleFindingsSnapshot(t, "unicorn/consistent-destructuring", rewritten, nil)
+  if len(converged) != 0 {
+    t.Fatalf("accepted suggestion still reports: %+v", converged)
+  }
+}