eslint-plugin-perfectionist 5.4.0 → 5.6.0

package/dist/package.json.js

@@ -1,3 +1,3 @@
 const name = 'eslint-plugin-perfectionist'
-const version = '5.4.0'
+const version = '5.6.0'
 export { name, version }

package/dist/rules/sort-array-includes/types.d.ts

@@ -28,8 +28,8 @@ export type Options = Partial<
   >
 >[]
 /**
- * Represents the type of array element selector. Used to distinguish between
- * literal values and spread elements in arrays.
+ * Represents the type of array element selector. Note: Spread elements are not
+ * sorted and act as partition boundaries.
  */
 export type Selector = (typeof allSelectors)[number]
 /**
@@ -39,14 +39,18 @@ export type Selector = (typeof allSelectors)[number]
  * and sorted based on their names and types.
  *
  * @example
- *   {
- *     "selector": "literal"
- *   }
+ *
+ * ```ts
+ * {
+ *   "selector": "literal"
+ * }
+ * ```
  */
 interface CustomGroupMatchOptions {
   /**
-   * Specifies the type of array elements to include in this group. Can be
-   * 'literal' for literal values or 'spread' for spread elements.
+   * Specifies the type of array elements to include in this group. Only
+   * 'literal' is available since spread elements create partition boundaries
+   * and are not sorted.
    */
   selector?: Selector
 }
@@ -55,7 +59,7 @@ type AdditionalSortOptions = object
  * Complete list of available selectors for array elements. Used for validation
  * and JSON schema generation.
  */
-export declare let allSelectors: readonly ['literal', 'spread']
+export declare let allSelectors: readonly ['literal']
 /**
  * Additional custom group match options JSON schema. Used by ESLint to validate
  * rule options at configuration time.

package/dist/rules/sort-array-includes/types.js

@@ -1,5 +1,5 @@
 import { buildCustomGroupSelectorJsonSchema } from '../../utils/json-schemas/common-groups-json-schemas.js'
-let allSelectors = ['literal', 'spread']
+let allSelectors = ['literal']
 let additionalCustomGroupMatchOptionsJsonSchema = {
   selector: buildCustomGroupSelectorJsonSchema(allSelectors),
 }

package/dist/rules/sort-array-includes.js

@@ -86,9 +86,9 @@ const sortArrayIncludes = createEslintRule({
         node.property.name === 'includes'
       ) {
         let elements =
-          node.object.type === AST_NODE_TYPES.ArrayExpression
-            ? node.object.elements
-            : node.object.arguments
+          node.object.type === AST_NODE_TYPES.ArrayExpression ?
+            node.object.elements
+          : node.object.arguments
         sortArray({
           availableMessageIds: {
             missedSpacingBetweenMembers: MISSED_SPACING_ERROR_ID,
@@ -151,9 +151,12 @@ function sortArray({ availableMessageIds, elements, context }) {
       if (element === null) {
         return accumulator
       }
+      if (element.type === AST_NODE_TYPES.SpreadElement) {
+        accumulator.push([])
+        return accumulator
+      }
       let name = getNodeName({ sourceCode, element })
-      let selector =
-        element.type === AST_NODE_TYPES.SpreadElement ? 'spread' : 'literal'
+      let selector = 'literal'
       let predefinedGroups = generatePredefinedGroups({
         cache: cachedGroupsByModifiersAndSelectors,
         selectors: [selector],
@@ -217,8 +220,8 @@ function sortArray({ availableMessageIds, elements, context }) {
   })
 }
 function getNodeName({ sourceCode, element }) {
-  return element.type === AST_NODE_TYPES.Literal
-    ? `${element.value}`
+  return element.type === AST_NODE_TYPES.Literal ?
+      `${element.value}`
     : sourceCode.getText(element)
 }
 export { sortArrayIncludes as default, defaultOptions, jsonSchema, sortArray }

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.d.ts

@@ -0,0 +1,27 @@
+import { TSESTree } from '@typescript-eslint/types'
+import { TSESLint } from '@typescript-eslint/utils'
+import { SortClassesSortingNode } from './types.js'
+import { RegexOption } from '../../types/common-options.js'
+type SortingNodeWithoutDependencies = Omit<
+  SortClassesSortingNode,
+  'dependencies'
+>
+export declare function computeDependenciesBySortingNode({
+  ignoreCallbackDependenciesPatterns,
+  sortingNodes,
+  sourceCode,
+  classBody,
+}: {
+  ignoreCallbackDependenciesPatterns: RegexOption
+  sortingNodes: SortingNodeWithoutDependencies[]
+  sourceCode: TSESLint.SourceCode
+  classBody: TSESTree.ClassBody
+}): Map<SortingNodeWithoutDependencies, SortingNodeWithoutDependencies[]>
+export declare function computeThisExpressionsInsideClassElement({
+  classElement,
+  sourceCode,
+}: {
+  classElement: TSESTree.ClassElement
+  sourceCode: TSESLint.SourceCode
+}): TSESTree.ThisExpression[]
+export {}

package/dist/rules/sort-classes/compute-dependencies-by-sorting-node.js

@@ -0,0 +1,189 @@
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils'
+import { computeDependenciesBySortingNode as computeDependenciesBySortingNode$1 } from '../../utils/compute-dependencies-by-sorting-node.js'
+import { computeParentNodesWithTypes } from '../../utils/compute-parent-nodes-with-types.js'
+import { computeIdentifierNameDetails } from './compute-identifier-name-details.js'
+import { UnreachableCaseError } from '../../utils/unreachable-case-error.js'
+import { matches } from '../../utils/matches.js'
+function computeDependenciesBySortingNode({
+  ignoreCallbackDependenciesPatterns,
+  sortingNodes,
+  sourceCode,
+  classBody,
+}) {
+  let staticSortingNodes = sortingNodes.filter(node => node.isStatic)
+  let dependenciesBySortingNode = computeDependenciesBySortingNode$1({
+    additionalIdentifierDependenciesComputer:
+      buildAdditionalIdentifierDependenciesComputer({
+        ignoreCallbackDependenciesPatterns,
+        staticSortingNodes,
+        classBody,
+      }),
+    shouldIgnoreSortingNodeComputer: sortingNode =>
+      shouldIgnoreDependencyComputation(sortingNode.node),
+    sortingNodes,
+    sourceCode,
+  })
+  let thisDependenciesBySortingNode =
+    computeThisExpressionDependenciesBySortingNode({
+      ignoreCallbackDependenciesPatterns,
+      sortingNodes,
+      sourceCode,
+    })
+  for (let [sortingNode, dependencies] of thisDependenciesBySortingNode) {
+    let existingDependencies = dependenciesBySortingNode.get(sortingNode) ?? []
+    dependenciesBySortingNode.set(sortingNode, [
+      ...existingDependencies,
+      ...dependencies,
+    ])
+  }
+  return dependenciesBySortingNode
+}
+function computeThisExpressionsInsideClassElement({
+  classElement,
+  sourceCode,
+}) {
+  let thisTokens = sourceCode.getTokens(classElement).filter(isThisToken)
+  return thisTokens
+    .map(computeTokenNode)
+    .filter(node => node?.type === AST_NODE_TYPES.ThisExpression)
+  function computeTokenNode(token) {
+    return sourceCode.getNodeByRangeIndex(token.range[0])
+  }
+  function isThisToken(token) {
+    return token.type === AST_TOKEN_TYPES.Keyword && token.value === 'this'
+  }
+}
+function computeIdentifierOrThisExpressionDependency({
+  ignoreCallbackDependenciesPatterns,
+  sortingNodes,
+  classElement,
+  node,
+}) {
+  if (shouldIgnoreCallbackDependency()) {
+    return null
+  }
+  let { parent } = node
+  if (parent.type !== AST_NODE_TYPES.MemberExpression) {
+    return null
+  }
+  let dependencyName = computeDependencyNameFromMemberExpression(parent)
+  if (!dependencyName) {
+    return null
+  }
+  return (
+    sortingNodes.find(
+      currentSortingNode => currentSortingNode.name === dependencyName.name,
+    ) ?? null
+  )
+  function computeDependencyNameFromMemberExpression(memberExpression) {
+    switch (memberExpression.property.type) {
+      case AST_NODE_TYPES.PrivateIdentifier:
+      case AST_NODE_TYPES.Identifier:
+      case AST_NODE_TYPES.Literal:
+        return computeIdentifierNameDetails(memberExpression.property)
+      /* v8 ignore next 2 -- @preserve Unhandled cases */
+      default:
+        return null
+    }
+  }
+  function shouldIgnoreCallbackDependency() {
+    let [firstCallExpressionParent] = computeParentNodesWithTypes({
+      allowedTypes: [AST_NODE_TYPES.CallExpression],
+      maxParent: classElement,
+      consecutiveOnly: false,
+      node,
+    })
+    if (!firstCallExpressionParent) {
+      return false
+    }
+    if (!('name' in firstCallExpressionParent.callee)) {
+      return false
+    }
+    return matches(
+      firstCallExpressionParent.callee.name,
+      ignoreCallbackDependenciesPatterns,
+    )
+  }
+}
+function computeThisExpressionDependenciesBySortingNode({
+  ignoreCallbackDependenciesPatterns,
+  sortingNodes,
+  sourceCode,
+}) {
+  let dependenciesBySortingNode = /* @__PURE__ */ new Map()
+  let staticSortingNodes = sortingNodes.filter(node => node.isStatic)
+  let nonStaticSortingNodes = sortingNodes.filter(node => !node.isStatic)
+  let relevantSortingNodes = sortingNodes.filter(
+    sortingNode => !shouldIgnoreDependencyComputation(sortingNode.node),
+  )
+  for (let sortingNode of relevantSortingNodes) {
+    let thisExpressions = computeThisExpressionsInsideClassElement({
+      classElement: sortingNode.node,
+      sourceCode,
+    })
+    let dependencies = thisExpressions
+      .map(thisExpression =>
+        computeIdentifierOrThisExpressionDependency({
+          sortingNodes:
+            sortingNode.isStatic ? staticSortingNodes : nonStaticSortingNodes,
+          ignoreCallbackDependenciesPatterns,
+          classElement: sortingNode.node,
+          node: thisExpression,
+        }),
+      )
+      .filter(dependency => dependency !== null)
+    if (dependencies.length === 0) {
+      continue
+    }
+    dependenciesBySortingNode.set(sortingNode, dependencies)
+  }
+  return dependenciesBySortingNode
+}
+function buildAdditionalIdentifierDependenciesComputer({
+  ignoreCallbackDependenciesPatterns,
+  staticSortingNodes,
+  classBody,
+}) {
+  return ({ referencingSortingNode, reference }) => {
+    let resolvedClassIdentifier = reference.resolved?.identifiers[0]
+    if (!resolvedClassIdentifier) {
+      return []
+    }
+    let classIdentifier = classBody.parent.id
+    if (reference.resolved?.identifiers[0] !== classIdentifier) {
+      return []
+    }
+    let dependency = computeIdentifierOrThisExpressionDependency({
+      classElement: referencingSortingNode.node,
+      ignoreCallbackDependenciesPatterns,
+      sortingNodes: staticSortingNodes,
+      node: reference.identifier,
+    })
+    return dependency ? [dependency] : []
+  }
+}
+function shouldIgnoreDependencyComputation(node) {
+  switch (node.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.StaticBlock:
+      return false
+    case AST_NODE_TYPES.TSAbstractAccessorProperty:
+    case AST_NODE_TYPES.AccessorProperty:
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.TSIndexSignature:
+      return true
+    case AST_NODE_TYPES.PropertyDefinition:
+      return (
+        node.value?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.value?.type === AST_NODE_TYPES.FunctionExpression
+      )
+    /* v8 ignore next 2 -- @preserve Exhaustive guard. */
+    default:
+      throw new UnreachableCaseError(node)
+  }
+}
+export {
+  computeDependenciesBySortingNode,
+  computeThisExpressionsInsideClassElement,
+}

package/dist/rules/sort-classes/compute-dependencies.d.ts

@@ -3,9 +3,12 @@ import { RegexOption } from '../../types/common-options.js'
 /**
  * Computes the dependencies of a class member AST node.
  *
+ * @deprecated - To remove when experimental dependency detection is the only.
  * @param params - Parameters object.
  * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore
  *   callback dependencies.
+ * @param params.useExperimentalDependencyDetection - Whether to use
+ *   experimental dependency detection.
  * @param params.isMemberStatic - Indicates if the member is static.
  * @param params.expression - The AST node expression to analyze.
  * @param params.className - The name of the class, if available.
@@ -13,12 +16,14 @@ import { RegexOption } from '../../types/common-options.js'
  */
 export declare function computeDependencies({
   ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   isMemberStatic,
   expression,
   className,
 }: {
   expression: TSESTree.StaticBlock | TSESTree.Expression
   ignoreCallbackDependenciesPatterns: RegexOption
+  useExperimentalDependencyDetection: boolean
   className: undefined | string
   isMemberStatic: boolean
 }): string[]

package/dist/rules/sort-classes/compute-dependencies.js

@@ -4,11 +4,17 @@ import { computeDependencyName } from './compute-dependency-name.js'
 import { matches } from '../../utils/matches.js'
 function computeDependencies({
   ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   isMemberStatic,
   expression,
   className,
 }) {
+  if (useExperimentalDependencyDetection) {
+    return []
+  }
   let dependencies = []
+  traverseNode(expression)
+  return dependencies
   function checkNode(nodeValue) {
     switch (nodeValue.type) {
       case AST_NODE_TYPES.ConditionalExpression:
@@ -97,8 +103,6 @@ function computeDependencies({
       checkNode(nodeValue)
     }
   }
-  traverseNode(expression)
-  return dependencies
 }
 function computeMemberExpressionDependencies({
   memberExpression,
@@ -109,8 +113,8 @@ function computeMemberExpressionDependencies({
     case AST_NODE_TYPES.ThisExpression:
       return computeIdentifierOrThisExpressionDependencies()
     case AST_NODE_TYPES.Identifier:
-      return memberExpression.object.name === className
-        ? computeIdentifierOrThisExpressionDependencies()
+      return memberExpression.object.name === className ?
+          computeIdentifierOrThisExpressionDependencies()
         : []
     default:
       return []

package/dist/rules/sort-classes/compute-identifier-name-details.d.ts

@@ -1,9 +1,5 @@
 import { TSESTree } from '@typescript-eslint/types'
-export interface NodeNameDetails {
-  nameWithoutStartingHash: string
-  hasPrivateHash: boolean
-  name: string
-}
+import { NodeNameDetails } from './types.js'
 /**
  * Computes the name details of an identifier.
  *

package/dist/rules/sort-classes/compute-overload-signature-groups.js

@@ -17,9 +17,8 @@ function computeOverloadSignatureGroups(classElements) {
       continue
     }
     let { name } = method.key
-    let mapToUse = method.static
-      ? staticOverloadSignaturesByName
-      : overloadSignaturesByName
+    let mapToUse =
+      method.static ? staticOverloadSignaturesByName : overloadSignaturesByName
     let overloadSignaturesArray = mapToUse.get(name)
     if (!overloadSignaturesArray) {
       overloadSignaturesArray = []

package/dist/rules/sort-classes/is-known-class-element.d.ts

@@ -0,0 +1,13 @@
+import { TSESTree } from '@typescript-eslint/types'
+/**
+ * Checks whether a class element is supported by the sort-classes rule.
+ *
+ * Unknown elements should be ignored to avoid crashes with non-standard parsers
+ * while letting known elements keep their ordering behavior.
+ *
+ * @param member - The class element to check.
+ * @returns True when the element is a known, supported class member.
+ */
+export declare function isKnownClassElement(
+  member: TSESTree.ClassElement,
+): boolean

package/dist/rules/sort-classes/is-known-class-element.js

@@ -0,0 +1,17 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils'
+function isKnownClassElement(member) {
+  switch (member.type) {
+    case AST_NODE_TYPES.TSAbstractPropertyDefinition:
+    case AST_NODE_TYPES.TSAbstractMethodDefinition:
+    case AST_NODE_TYPES.TSAbstractAccessorProperty:
+    case AST_NODE_TYPES.PropertyDefinition:
+    case AST_NODE_TYPES.MethodDefinition:
+    case AST_NODE_TYPES.AccessorProperty:
+    case AST_NODE_TYPES.TSIndexSignature:
+    case AST_NODE_TYPES.StaticBlock:
+      return true
+    default:
+      return false
+  }
+}
+export { isKnownClassElement }

package/dist/rules/sort-classes/node-info/compute-accessor-details.d.ts

@@ -1,6 +1,6 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
-import { Modifier, Selector } from '../types.js'
+import { NodeNameDetails, Modifier, Selector } from '../types.js'
 /**
  * Computes details related to an accessor property.
  *
@@ -19,8 +19,9 @@ export declare function computeAccessorDetails({
   sourceCode: TSESLint.SourceCode
   isDecorated: boolean
 }): {
+  nameDetails: NodeNameDetails
   dependencyNames: string[]
   modifiers: Modifier[]
   selectors: Selector[]
-  name: string
+  isStatic: boolean
 }

package/dist/rules/sort-classes/node-info/compute-accessor-details.js

@@ -8,24 +8,24 @@ import {
 import { computeMethodOrPropertyNameDetails } from './compute-method-or-property-name-details.js'
 import { computeDependencyName } from '../compute-dependency-name.js'
 function computeAccessorDetails({ isDecorated, sourceCode, accessor }) {
-  let { nameWithoutStartingHash, hasPrivateHash, name } =
-    computeMethodOrPropertyNameDetails(accessor, sourceCode)
+  let nameDetails = computeMethodOrPropertyNameDetails(accessor, sourceCode)
   let modifiers = computeModifiers({
-    hasPrivateHash,
+    hasPrivateHash: nameDetails.hasPrivateHash,
     isDecorated,
     accessor,
   })
   return {
     dependencyNames: [
       computeDependencyName({
-        nodeNameWithoutStartingHash: nameWithoutStartingHash,
+        nodeNameWithoutStartingHash: nameDetails.nameWithoutStartingHash,
+        hasPrivateHash: nameDetails.hasPrivateHash,
         isStatic: modifiers.includes('static'),
-        hasPrivateHash,
       }),
     ],
     selectors: ['accessor-property'],
+    isStatic: accessor.static,
+    nameDetails,
     modifiers,
-    name,
   }
 }
 function computeModifiers({ hasPrivateHash, isDecorated, accessor }) {

package/dist/rules/sort-classes/node-info/compute-method-details.d.ts

@@ -1,6 +1,6 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
-import { Modifier, Selector } from '../types.js'
+import { NodeNameDetails, Modifier, Selector } from '../types.js'
 /**
  * Computes details related to a method.
  *
@@ -23,7 +23,8 @@ export declare function computeMethodDetails({
   isDecorated: boolean
 }): {
   addSafetySemicolonWhenInline: boolean
+  nameDetails: NodeNameDetails
   modifiers: Modifier[]
   selectors: Selector[]
-  name: string
+  isStatic: boolean
 }

package/dist/rules/sort-classes/node-info/compute-method-details.js

@@ -16,22 +16,20 @@ function computeMethodDetails({
   sourceCode,
   method,
 }) {
-  let { hasPrivateHash, name } = computeMethodOrPropertyNameDetails(
-    method,
-    sourceCode,
-  )
+  let nameDetails = computeMethodOrPropertyNameDetails(method, sourceCode)
   return {
-    addSafetySemicolonWhenInline: shouldAddSafetySemicolonWhenInline({
-      hasParentDeclare,
-      method,
-    }),
     modifiers: computeModifiers({
-      hasPrivateHash,
+      hasPrivateHash: nameDetails.hasPrivateHash,
       isDecorated,
       method,
     }),
+    addSafetySemicolonWhenInline: shouldAddSafetySemicolonWhenInline({
+      hasParentDeclare,
+      method,
+    }),
     selectors: computeSelectors(method),
-    name,
+    isStatic: method.static,
+    nameDetails,
   }
 }
 function computeSelectors(method) {

package/dist/rules/sort-classes/node-info/compute-method-or-property-name-details.d.ts

@@ -1,6 +1,6 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
-import { NodeNameDetails } from '../compute-identifier-name-details.js'
+import { NodeNameDetails } from '../types.js'
 /**
  * Computes the name details of a method or property node.
  *

package/dist/rules/sort-classes/node-info/compute-property-details.d.ts

@@ -1,7 +1,7 @@
 import { TSESTree } from '@typescript-eslint/types'
 import { TSESLint } from '@typescript-eslint/utils'
+import { NodeNameDetails, Modifier, Selector } from '../types.js'
 import { RegexOption } from '../../../types/common-options.js'
-import { Modifier, Selector } from '../types.js'
 /**
  * Computes details related to a property.
  *
@@ -10,12 +10,15 @@ import { Modifier, Selector } from '../types.js'
  * @param params.property - The property node to compute information for.
  * @param params.ignoreCallbackDependenciesPatterns - Patterns to ignore when
  *   computing dependencies.
+ * @param params.useExperimentalDependencyDetection - Whether to use
+ *   experimental dependency detection.
  * @param params.sourceCode - The source code object.
  * @param params.className - The name of the class containing the property.
  * @returns An object containing various details about the property.
  */
 export declare function computePropertyDetails({
   ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   isDecorated,
   sourceCode,
   className,
@@ -23,14 +26,16 @@ export declare function computePropertyDetails({
 }: {
   property: TSESTree.TSAbstractPropertyDefinition | TSESTree.PropertyDefinition
   ignoreCallbackDependenciesPatterns: RegexOption
+  useExperimentalDependencyDetection: boolean
   sourceCode: TSESLint.SourceCode
   className: undefined | string
   isDecorated: boolean
 }): {
   memberValue: undefined | string
+  nameDetails: NodeNameDetails
   dependencyNames: string[]
   dependencies: string[]
   modifiers: Modifier[]
   selectors: Selector[]
-  name: string
+  isStatic: boolean
 }

package/dist/rules/sort-classes/node-info/compute-property-details.js

@@ -14,38 +14,40 @@ import { computeDependencyName } from '../compute-dependency-name.js'
 import { computeDependencies } from '../compute-dependencies.js'
 function computePropertyDetails({
   ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   isDecorated,
   sourceCode,
   className,
   property,
 }) {
-  let { nameWithoutStartingHash, hasPrivateHash, name } =
-    computeMethodOrPropertyNameDetails(property, sourceCode)
+  let nameDetails = computeMethodOrPropertyNameDetails(property, sourceCode)
   let modifiers = computeModifiers({
-    hasPrivateHash,
+    hasPrivateHash: nameDetails.hasPrivateHash,
     isDecorated,
     property,
   })
   return {
     dependencyNames: [
       computeDependencyName({
-        nodeNameWithoutStartingHash: nameWithoutStartingHash,
+        nodeNameWithoutStartingHash: nameDetails.nameWithoutStartingHash,
+        hasPrivateHash: nameDetails.hasPrivateHash,
         isStatic: modifiers.includes('static'),
-        hasPrivateHash,
       }),
     ],
-    memberValue:
-      !isFunctionExpression(property.value) && property.value
-        ? sourceCode.getText(property.value)
-        : void 0,
     dependencies: computePropertyDependencies({
       ignoreCallbackDependenciesPatterns,
+      useExperimentalDependencyDetection,
       className,
       property,
     }),
+    memberValue:
+      !isFunctionExpression(property.value) && property.value ?
+        sourceCode.getText(property.value)
+      : void 0,
     selectors: computeSelectors(property),
+    isStatic: property.static,
+    nameDetails,
     modifiers,
-    name,
   }
 }
 function computeModifiers({ hasPrivateHash, isDecorated, property }) {
@@ -75,6 +77,7 @@ function computeModifiers({ hasPrivateHash, isDecorated, property }) {
 }
 function computePropertyDependencies({
   ignoreCallbackDependenciesPatterns,
+  useExperimentalDependencyDetection,
   className,
   property,
 }) {
@@ -86,6 +89,7 @@ function computePropertyDependencies({
   }
   return computeDependencies({
     ignoreCallbackDependenciesPatterns,
+    useExperimentalDependencyDetection,
     isMemberStatic: property.static,
     expression: property.value,
     className,