Add more documentation on how this rule works

Author: meowbmw

docs/rules/no-repeated-member-access.md

@@ -94,7 +94,6 @@ function singleAccess(obj: MyObject): void {
 - **Performance**: Reduces redundant property lookups, especially in tight loops
 - **Readability**: Makes code more readable by giving meaningful names to complex property chains
 - **Maintainability**: Easier to update property references when extracted to variables
-- **Memory Efficiency**: Can reduce memory pressure in performance-critical AssemblyScript code
 
 ## When Not To Use
 

plugins/rules/memberAccess.ts

@@ -2,6 +2,33 @@ import { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/utils";
 import { Scope } from "@typescript-eslint/utils/ts-eslint";
 import createRule from "../utils/createRule.js";
 
+/**
+ * Rule to optimize repeated member access patterns by extracting variables
+ * For more rule details refer to docs/rules/no-repeated-member-access.md
+ *
+ * The following material is an overview of implementation details
+ * It is divided into several phases
+ *
+ * 1. Analysis Phase:
+ *    - Traverse AST to identify member access chains (e.g., obj.prop.val)
+ *    - Store chains into hierarchical structures (e.g., ["obj", "obj.prop", "obj.prop.val"])
+ *    - Cache analysis results to avoid repeatedly processing
+ *
+ * 2. Tracking Phase:
+ *    - Count usage frequency of each chain within current scope
+ *    - Identify modified chains (assignments, increments, function calls, etc.)
+ *    - Mark all parts alongside the chain as modified
+ *
+ * 3. Reporting Phase:
+ *    - For chains that meet usage threshold and are not modified, suggest variable extraction
+ *    - Report only the longest valid chains
+ *
+ * Things to note:
+ * - Only process chains starting with identifiers or "this" (avoid function call results)
+ * - Skip computed property access (e.g., obj[key])
+ * - Mark modified chains as un-extractable
+ * - Support TypeScript non-null assertion operator (!) (minor bugs might still persist in some cases)
+ */
 const noRepeatedMemberAccess = createRule({
   name: "no-repeated-member-access",
   meta: {
@@ -42,7 +69,6 @@ const noRepeatedMemberAccess = createRule({
           modified: boolean; // Whether this chain is modified (written to)
         }
       >;
-      variables: Set<string>; // Variables already declared in this scope
     };
 
     // Stores data for each scope using WeakMap to avoid memory leaks
@@ -63,15 +89,8 @@ const noRepeatedMemberAccess = createRule({
               modified: boolean;
             }
           >(),
-          variables: new Set<string>(),
         };
 
-        // Add existing variable names to the set
-        for (let i = 0; i < scope.variables.length; i++) {
-          const variable = scope.variables[i];
-          newScopeData.variables.add(variable.name);
-        }
-
         scopeDataMap.set(scope, newScopeData);
       }
 
@@ -132,8 +151,7 @@ const noRepeatedMemberAccess = createRule({
         parts.push("this");
       } else {
         // Skip chains with non-identifier base objects
-        // Example: (getObject()).prop is not optimized because
-        // function call results shouldn't be cached
+        // Example: (getObject()).prop is not optimized because function call results shouldn't be cached
         isValid = false;
       }
 
@@ -200,7 +218,7 @@ const noRepeatedMemberAccess = createRule({
         }
       }
       // Mark the chain as modified regardless of it has been created or not!! Otherwise properties that get written will be reported in the first time, but they should not be reported.
-      // Examples:
+      // Here is a more concrete example:
       // "this.vehicleSys!" should not be extracted as it is written later
       // this.vehicleSys!.automobile = new TransportCore(new TransportBlueprint()); // THIS line will get reported if we don't mark the chain as modified
       // this.vehicleSys!.automobile!.apple = new ChassisAssembly(new ChassisSchema());