Update @eslint-community/regexpp to v4.6 (#554)

ota-meshi · web-flow · commit 0aa9b8fa0b70 · 2023-08-15T11:41:11.000+02:00
* Update `@eslint-community/regexpp` to v4.6

* Create small-doors-lie.md

* avoid lint error
diff --git a/.changeset/small-doors-lie.md b/.changeset/small-doors-lie.md
@@ -0,0 +1,5 @@
+---
+"eslint-plugin-regexp": minor
+---
+
+Update `@eslint-community/regexpp` to v4.6
diff --git a/lib/rules/negation.ts b/lib/rules/negation.ts
@@ -58,6 +58,8 @@ export default createRule("negation", {
                         const negatedElementSet = toCharSet(
                             {
                                 ...element,
+                                // FIXME: TS Error
+                                // @ts-expect-error -- FIXME
                                 negate: !element.negate,
                             },
                             flags,
diff --git a/lib/rules/no-contradiction-with-assertion.ts b/lib/rules/no-contradiction-with-assertion.ts
@@ -102,8 +102,10 @@ function* getNextElements(
             }
         }
 
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         const elements = parent.elements
-        const index = elements.indexOf(element)
+        const index = elements.indexOf(element) as number
         const inc = dir === "ltr" ? 1 : -1
         for (let i = index + inc; i >= 0 && i < elements.length; i += inc) {
             const e = elements[i]
diff --git a/lib/rules/no-dupe-characters-character-class.ts b/lib/rules/no-dupe-characters-character-class.ts
@@ -67,6 +67,8 @@ function groupElements(
     }
 
     for (const e of elements) {
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         const charSet = toCharSet(e, flags)
 
         if (e.type === "Character") {
@@ -324,6 +326,8 @@ export default createRule("no-dupe-characters-character-class", {
                                 .filter((e) => !subsets.has(e) && e !== element)
                                 .filter(
                                     (e) =>
+                                        // FIXME: TS Error
+                                        // @ts-expect-error -- FIXME
                                         !toCharSet(e, flags).isDisjointWith(
                                             elementCharSet,
                                         ),
diff --git a/lib/rules/no-dupe-disjunctions.ts b/lib/rules/no-dupe-disjunctions.ts
@@ -875,6 +875,8 @@ function fixRemoveNestedAlternative(
         }
 
         default:
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             throw assertNever(alternative)
     }
 }
diff --git a/lib/rules/no-misleading-capturing-group.ts b/lib/rules/no-misleading-capturing-group.ts
@@ -91,6 +91,8 @@ function* getStartQuantifiers(
             }
             break
         default:
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             yield assertNever(root)
     }
 }
@@ -179,6 +181,8 @@ function uncachedGetSingleRepeatedChar(
             return getSingleRepeatedChar(element.element, flags, cache)
 
         default:
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             return assertNever(element)
     }
 }
@@ -232,6 +236,8 @@ function getTradingQuantifiersAfter(
                         return state
 
                     default:
+                        // FIXME: TS Error
+                        // @ts-expect-error -- FIXME
                         return assertNever(element)
                 }
             },
diff --git a/lib/rules/optimal-quantifier-concatenation.ts b/lib/rules/optimal-quantifier-concatenation.ts
@@ -513,8 +513,12 @@ function getLoc(
 function getCapturingGroupStack(element: Element): string {
     let result = ""
     for (
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         let p: Ancestor<Element> = element.parent;
         p.type !== "Pattern";
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         p = p.parent
     ) {
         if (p.type === "CapturingGroup") {
diff --git a/lib/rules/prefer-character-class.ts b/lib/rules/prefer-character-class.ts
@@ -124,6 +124,8 @@ function elementsToCharacterClass(elements: CharElementArray): string {
                 break
 
             default:
+                // FIXME: TS Error
+                // @ts-expect-error -- FIXME
                 throw new Error(e)
         }
     })
diff --git a/lib/rules/sort-character-class-elements.ts b/lib/rules/sort-character-class-elements.ts
@@ -241,6 +241,8 @@ export default createRule("sort-character-class-elements", {
             if (node.type === "CharacterClassRange") {
                 return node.min.value
             }
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             return node.value
         }
 
@@ -257,6 +259,8 @@ function escapeRaw(node: CharacterClassElement, target: CharacterClassElement) {
     let raw = node.raw
     if (raw.startsWith("-")) {
         const parent = target.parent as CharacterClass
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         const prev = parent.elements[parent.elements.indexOf(target) - 1]
         if (
             prev &&
diff --git a/lib/rules/use-ignore-case.ts b/lib/rules/use-ignore-case.ts
@@ -19,6 +19,8 @@ import type {
 import type { Rule } from "eslint"
 import { UsageOfPattern } from "../utils/get-usage-of-pattern"
 
+// FIXME: TS Error
+// @ts-expect-error -- FIXME
 const ELEMENT_ORDER: Record<CharacterClassElement["type"], number> = {
     Character: 1,
     CharacterClassRange: 2,
@@ -177,6 +179,8 @@ export default createRule("use-ignore-case", {
                     }
 
                     const invariant = Chars.empty(flags).union(
+                        // FIXME: TS Error
+                        // @ts-expect-error -- FIXME
                         ...invariantElement.map((e) => toCharSet(e, flags)),
                     )
 
@@ -189,6 +193,8 @@ export default createRule("use-ignore-case", {
                     // the i flag
                     const alwaysUseless = findUseless(
                         variantElements,
+                        // FIXME: TS Error
+                        // @ts-expect-error -- FIXME
                         (e) => toCharSet(e, flags),
                         invariant,
                     )
@@ -200,6 +206,8 @@ export default createRule("use-ignore-case", {
                     const iFlags = getIgnoreCaseFlags(flags)
                     const useless = findUseless(
                         variantElements,
+                        // FIXME: TS Error
+                        // @ts-expect-error -- FIXME
                         (e) => toCharSet(e, iFlags),
                         invariant,
                     )
diff --git a/lib/utils/index.ts b/lib/utils/index.ts
@@ -1196,8 +1196,12 @@ export function fixRemoveCharacterClassElement(
         }
 
         const elementBefore: CharacterClassElement | undefined =
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             cc.elements[cc.elements.indexOf(element) - 1]
         const elementAfter: CharacterClassElement | undefined =
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             cc.elements[cc.elements.indexOf(element) + 1]
 
         if (
diff --git a/lib/utils/partial-parser.ts b/lib/utils/partial-parser.ts
@@ -181,6 +181,8 @@ export class PartialParser {
             }
 
             default:
+                // FIXME: TS Error
+                // @ts-expect-error -- FIXME
                 throw assertNever(element)
         }
     }
@@ -207,6 +209,8 @@ export class PartialParser {
                 characters: JS.createCharSet([range], this.parser.ast.flags),
             }
         }
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         return this.nativeParseElement(context.alternative)
     }
 
diff --git a/lib/utils/regexp-ast/case-variation.ts b/lib/utils/regexp-ast/case-variation.ts
@@ -134,6 +134,8 @@ export function isCaseVariant(
 
                 case "CharacterClass":
                     if (!wholeCharacterClass) {
+                        // FIXME: TS Error
+                        // @ts-expect-error -- FIXME
                         return d.elements.some(ccElementIsCaseVariant)
                     }
                     // just check for equality
diff --git a/lib/utils/regexp-ast/index.ts b/lib/utils/regexp-ast/index.ts
@@ -155,6 +155,8 @@ export function getJSRegexppAst(
 
     return {
         pattern: patternAst,
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         flags: {
             type: "Flags",
             raw: flagsString ?? "",
diff --git a/lib/utils/regexp-ast/is-equals.ts b/lib/utils/regexp-ast/is-equals.ts
@@ -227,6 +227,8 @@ export function isEqualNodes<N extends Node>(
         }
     }
     if (/[(*+?[\\{|]/u.test(a.raw) || /[(*+?[\\{|]/u.test(b.raw)) {
+        // FIXME: TS Error
+        // @ts-expect-error -- FIXME
         return EQUALS_CHECKER[a.type](
             a as never,
             b as never,
diff --git a/lib/utils/regexp-ast/simplify-quantifier.ts b/lib/utils/regexp-ast/simplify-quantifier.ts
@@ -418,6 +418,8 @@ function getTailQuantifiers(
         }
 
         default:
+            // FIXME: TS Error
+            // @ts-expect-error -- FIXME
             return assertNever(element)
     }
 }
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -103,7 +103,7 @@
     },
     "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
-        "@eslint-community/regexpp": "^4.4.0",
+        "@eslint-community/regexpp": "^4.6.2",
         "comment-parser": "^1.1.2",
         "grapheme-splitter": "^1.0.4",
         "jsdoctypeparser": "^9.0.0",

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"eslint-plugin-regexp": minor
 +---
++
 +Update `@eslint-community/regexpp` to v4.6
Original file line number	Diff line number	Diff line change
`@@ -58,6 +58,8 @@ export default createRule("negation", {`
`58`	`58`	`const negatedElementSet = toCharSet(`
`59`	`59`	`{`
`60`	`60`	`...element,`
	`61`	`+ // FIXME: TS Error`
	`62`	`+ // @ts-expect-error -- FIXME`
`61`	`63`	`negate: !element.negate,`
`62`	`64`	`},`
`63`	`65`	`flags,`
Original file line number	Diff line number	Diff line change
`@@ -102,8 +102,10 @@ function* getNextElements(`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
	`105`	`+ // FIXME: TS Error`
	`106`	`+ // @ts-expect-error -- FIXME`
`105`	`107`	`const elements = parent.elements`
`106`		`- const index = elements.indexOf(element)`
	`108`	`+ const index = elements.indexOf(element) as number`
`107`	`109`	`const inc = dir === "ltr" ? 1 : -1`
`108`	`110`	`for (let i = index + inc; i >= 0 && i < elements.length; i += inc) {`
`109`	`111`	`const e = elements[i]`
Original file line number	Diff line number	Diff line change
`@@ -875,6 +875,8 @@ function fixRemoveNestedAlternative(`
`875`	`875`	`}`
`876`	`876`
`877`	`877`	`default:`
	`878`	`+ // FIXME: TS Error`
	`879`	`+ // @ts-expect-error -- FIXME`
`878`	`880`	`throw assertNever(alternative)`
`879`	`881`	`}`
`880`	`882`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,6 +91,8 @@ function* getStartQuantifiers(`
`91`	`91`	`}`
`92`	`92`	`break`
`93`	`93`	`default:`
	`94`	`+ // FIXME: TS Error`
	`95`	`+ // @ts-expect-error -- FIXME`
`94`	`96`	`yield assertNever(root)`
`95`	`97`	`}`
`96`	`98`	`}`
`@@ -179,6 +181,8 @@ function uncachedGetSingleRepeatedChar(`
`179`	`181`	`return getSingleRepeatedChar(element.element, flags, cache)`
`180`	`182`
`181`	`183`	`default:`
	`184`	`+ // FIXME: TS Error`
	`185`	`+ // @ts-expect-error -- FIXME`
`182`	`186`	`return assertNever(element)`
`183`	`187`	`}`
`184`	`188`	`}`
`@@ -232,6 +236,8 @@ function getTradingQuantifiersAfter(`
`232`	`236`	`return state`
`233`	`237`
`234`	`238`	`default:`
	`239`	`+ // FIXME: TS Error`
	`240`	`+ // @ts-expect-error -- FIXME`
`235`	`241`	`return assertNever(element)`
`236`	`242`	`}`
`237`	`243`	`},`
Original file line number	Diff line number	Diff line change
`@@ -124,6 +124,8 @@ function elementsToCharacterClass(elements: CharElementArray): string {`
`124`	`124`	`break`
`125`	`125`
`126`	`126`	`default:`
	`127`	`+ // FIXME: TS Error`
	`128`	`+ // @ts-expect-error -- FIXME`
`127`	`129`	`throw new Error(e)`
`128`	`130`	`}`
`129`	`131`	`})`