set modified in constructor to ensure the flag is inhereited; construct path during constructor

Author: meowbmw

plugins/rules/memberAccess.ts

@@ -28,19 +28,23 @@ const noRepeatedMemberAccess = createRule({
     // Tree-based approach for storing member access chains
     // Each node represents a property in the chain (e.g., a -> b -> c for a.b.c)
     class ChainNode {
-      private name: string;
       private count: number = 0;
       private modified: boolean = false;
       private parent?: ChainNode;
       private children: Map<string, ChainNode> = new Map();
+      private path: string;
 
-      constructor(name: string) {
-        this.name = name;
-      }
+      constructor(name: string, parent?: ChainNode) {
+        this.parent = parent;
+        this.modified = this.parent?.modified || false;
 
-      // Getter methods for private properties
-      get getName(): string {
-        return this.name;
+        if (name === "__root__") {
+          this.path = "";
+        } else if (!this.parent || this.parent.path === "") {
+          this.path = name;
+        } else {
+          this.path = this.parent.path + "." + name;
+        }
       }
 
       get getCount(): number {
@@ -59,9 +63,8 @@ const noRepeatedMemberAccess = createRule({
         return this.children;
       }
 
-      // Setter methods for private properties
-      set setParent(parent: ChainNode | undefined) {
-        this.parent = parent;
+      get getPath(): string {
+        return this.path;
       }
 
       incrementCount(): void {
@@ -71,30 +74,15 @@ const noRepeatedMemberAccess = createRule({
       // Get or create child node
       getOrCreateChild(childName: string): ChainNode {
         if (!this.children.has(childName)) {
-          this.children.set(childName, new ChainNode(childName));
+          this.children.set(childName, new ChainNode(childName, this));
         }
         return this.children.get(childName)!;
       }
 
-      // Get the full chain path from root to this node
-      getChainPath(): string {
-        // Build path from child to root, then reverse at the end
-        const path: string[] = [];
-        let current = this as ChainNode | undefined;
-        while (current && current.getName !== "__root__") {
-          path.push(current.getName);
-          current = current.getParent;
-        }
-
-        // Reverse the array once at the end
-        path.reverse();
-        return path.join(".");
-      }
-
       // Mark this node and all its descendants as modified
       markAsModified(): void {
         this.modified = true;
-        for (const child of this.getChildren.values()) {
+        for (const child of this.children.values()) {
           child.markAsModified();
         }
       }
@@ -103,8 +91,6 @@ const noRepeatedMemberAccess = createRule({
     // Root node for the tree (per scope)
     class ChainTree {
       private root: ChainNode = new ChainNode("__root__");
-      private validChainsCache: Array<{ chain: string }> = [];
-      private cacheValid: boolean = false;
 
       // Insert a chain path into the tree and increment counts
       insertChain(properties: string[]): void {
@@ -113,15 +99,13 @@ const noRepeatedMemberAccess = createRule({
         // Navigate/create path in tree
         for (const prop of properties) {
           const child = current.getOrCreateChild(prop);
-          child.setParent = current;
           current = child;
 
           // Only increment count for non-single properties (chains with dots)
           if (properties.length > 1) {
             current.incrementCount();
           }
         }
-        this.cacheValid = false;
       }
 
       // Mark a chain and its descendants as modified
@@ -131,28 +115,22 @@ const noRepeatedMemberAccess = createRule({
         // Navigate to the target node, creating nodes if they don't exist
         for (const prop of properties) {
           const newChild = current.getOrCreateChild(prop);
-          newChild.setParent = current;
           current = newChild;
         }
 
         // Mark this node and all descendants as modified
         current.markAsModified();
-        this.cacheValid = false;
       }
 
       // Find any valid chain that meets the minimum occurrence threshold
       findValidChains() {
-        if (this.cacheValid) {
-          return this.validChainsCache;
-        }
         const validChains: Array<{ chain: string }> = [];
 
         const traverse = (node: ChainNode, depth: number) => {
           // Only consider chains with more than one segment (has dots)
           if (depth > 1 && !node.isModified && node.getCount >= 2) {
-            const chainPath = node.getChainPath();
             validChains.push({
-              chain: chainPath,
+              chain: node.getPath,
             });
           }
 
@@ -168,8 +146,6 @@ const noRepeatedMemberAccess = createRule({
         };
 
         traverse(this.root, 0);
-        this.cacheValid = true;
-        this.validChainsCache = validChains;
         return validChains;
       }
     }