Disable complexity rule (#575)

* Disable `complexity` rule

* one last error

* Removed useless comment

Author: RunDevelopment

.eslintrc.js

@@ -20,6 +20,7 @@ module.exports = {
         "require-jsdoc": "error",
         "no-warning-comments": "warn",
         "no-lonely-if": "off",
+        complexity: "off",
         "@typescript-eslint/no-non-null-assertion": "off",
 
         "no-shadow": "off",

lib/rules/no-dupe-characters-character-class.ts

@@ -255,7 +255,6 @@ export default createRule("no-dupe-characters-character-class", {
             const { flags } = regexpContext
 
             return {
-                // eslint-disable-next-line complexity -- X
                 onCharacterClassEnter(ccNode: CharacterClass) {
                     const {
                         duplicates,

lib/rules/no-misleading-capturing-group.ts

@@ -1,5 +1,5 @@
 /* eslint-disable eslint-comments/disable-enable-pair -- x */
-/* eslint-disable complexity -- x */
+
 import type { RegExpVisitor } from "@eslint-community/regexpp/visitor"
 import type {
     Alternative,

lib/rules/no-useless-character-class.ts

@@ -45,7 +45,6 @@ export default createRule("no-useless-character-class", {
             getRegexpLocation,
         }: RegExpContext): RegExpVisitor.Handlers {
             return {
-                // eslint-disable-next-line complexity -- X(
                 onCharacterClassEnter(ccNode) {
                     if (ccNode.elements.length !== 1) {
                         return

lib/rules/optimal-quantifier-concatenation.ts

@@ -1,5 +1,3 @@
-// eslint-disable-next-line eslint-comments/disable-enable-pair -- x
-/* eslint-disable complexity -- x */
 import type { RegExpVisitor } from "@eslint-community/regexpp/visitor"
 import type {
     Alternative,

lib/rules/sort-character-class-elements.ts

@@ -141,12 +141,10 @@ export default createRule("sort-character-class-elements", {
             }
         }
 
-        /* eslint-disable complexity -- X( */
         /**
          * Check that the two given CharacterClassElements are in a valid order.
          */
         function isValidOrder(
-            /* eslint-enable complexity -- X( */
             prev: CharacterClassElement,
             next: CharacterClassElement,
         ) {

lib/rules/strict.ts

@@ -133,7 +133,6 @@ export default createRule("strict", {
             }
 
             return {
-                // eslint-disable-next-line complexity -- x
                 onCharacterEnter(cNode) {
                     if (cNode.raw === "\\") {
                         // e.g. \c5 or \c

lib/utils/ast-utils/extract-expression-references.ts

@@ -94,10 +94,8 @@ export function* extractExpressionReferencesForVariable(
     })
 }
 
-/* eslint-disable complexity -- ignore */
 /** Iterate references from the given expression */
 function* iterateReferencesForExpression(
-    /* eslint-enable complexity -- ignore */
     expression: Expression,
     context: Rule.RuleContext,
     alreadyChecked: AlreadyChecked,

lib/utils/index.ts

@@ -1103,16 +1103,11 @@ export function toCharSetSource(
     ).source
 }
 
-/* eslint-disable complexity -- X( */
 /**
  * Returns whether the concatenation of the two string might create new escape
  * sequences or elements.
  */
-export function mightCreateNewElement(
-    /* eslint-enable complexity -- X( */
-    before: string,
-    after: string,
-): boolean {
+export function mightCreateNewElement(before: string, after: string): boolean {
     // control
     // \cA
     if (before.endsWith("\\c") && /^[a-z]/iu.test(after)) {

lib/utils/regexp-ast/is-covered.ts

@@ -335,10 +335,8 @@ export function isCoveredNode(
     return isCoveredForNormalizedNode(leftNode, rightNode, options)
 }
 
-/* eslint-disable complexity -- X( */
 /** Checks whether the right node is covered by the left node. */
 function isCoveredForNormalizedNode(
-    /* eslint-enable complexity -- X( */
     left: NormalizedNode,
     right: NormalizedNode,
     options: Options,
@@ -478,10 +476,8 @@ function isCoveredAnyNode(
     return false
 }
 
-/* eslint-disable complexity -- X( */
 /** Check whether the right nodes is covered by the left nodes. */
 function isCoveredAltNodes(
-    /* eslint-enable complexity -- X( */
     leftNodes: NormalizedNode[],
     rightNodes: NormalizedNode[],
     options: Options,