Feat: Add no-member-access rule (#5)

Author: xpirad

.gitignore

@@ -3,5 +3,4 @@ dist/
 sample_cases/
 wasm-toolchain
 coverage
-.vscode
 reference

Readme.md

@@ -25,10 +25,22 @@ Optimizes code for better WebAssembly performance:
 
 - `array-init-style`: Recommends using `new Array<T>()` instead of `[]` for initializing empty arrays
 
+- `no-repeated-member-access`: Recommends extracting repeated member access to improve performance
+
 ## Configuration
 
 See `sample_config/sample_eslint.config.mjs` for a detailed example of how to configure and use this plugin.
 
+It includes some other pre-written rules including:
+
+- `no-implicit-globals`: Warns against creating implicit global variables
+- `curly`: Requires curly braces for all control statements to prevent error-prone one-liner code
+- `@typescript-eslint/no-restricted-types`: Enforces AssemblyScript-specific type usage:
+  - Use `string` instead of `String`
+  - Use `bool` instead of `Boolean`
+  - Disallows unsupported types like `undefined` and `object`
+- `@typescript-eslint/adjacent-overload-signatures`: Requires overload signatures to be adjacent
+
 ## Documentation
 
 For detailed rule documentation, see the [docs/rules](./docs/rules) directory.

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

@@ -0,0 +1,94 @@
+# no-repeated-member-access
+
+> Optimize repeated member access patterns by extracting variables
+
+## Rule Details
+
+This rule identifies repeated member access patterns in your code and suggests extracting them to variables for better performance and readability. In AssemblyScript, repeated property access can have performance implications (due to when they are compiled to WASM bytecode, they will induce more instructions), especially in loops or frequently called functions.
+
+This rule doesn't extract computed properties/array index. These can change unexpectedly and therefore should be avoid for extraction. Examples include:
+
+```ts
+arr[0];
+arr[0][1];
+arr[0].property;
+obj.arr[0].value;
+data.items[0].config;
+obj["prop"];
+obj[getKey()];
+```
+
+The rule will also avoid to warn when functions are invoked upon properties, as this could have implications that alter the extracted value.
+Examples include:
+
+```ts
+x = a.b.c;
+a.b.doSomething(); // this line will prevent a.b.c from being warned although it is used multiple times, as doSomething() could potentially change the value of a.b
+y = a.b.c;
+z = a.b.c;
+```
+
+## Examples
+
+### Incorrect
+
+```ts
+// Repeated access to the same property chain (3+ times)
+function processData(obj: MyObject): void {
+  if (obj.config.settings.enabled) {
+    obj.config.settings.value = 10;
+    console.log(obj.config.settings.name);
+    obj.config.settings.timestamp = Date.now();
+  }
+}
+
+// Deep property chains accessed multiple times
+function renderUI(app: Application): void {
+  app.ui.layout.header.title.text = "New Title";
+  app.ui.layout.header.title.fontSize = 16;
+  app.ui.layout.header.title.color = "blue";
+}
+```
+
+### Correct
+
+```ts
+// Extract repeated property access to variables
+function processData(obj: MyObject): void {
+  const settings = obj.config.settings;
+  if (settings.enabled) {
+    settings.value = 10;
+    console.log(settings.name);
+    settings.timestamp = Date.now();
+  }
+}
+
+// Extract deep property chains
+function renderUI(app: Application): void {
+  const title = app.ui.layout.header.title;
+  title.text = "New Title";
+  title.fontSize = 16;
+  title.color = "blue";
+}
+
+// Single or infrequent access is allowed
+function singleAccess(obj: MyObject): void {
+  console.log(obj.config.settings.enabled); // Only accessed once
+}
+```
+
+## Benefits
+
+- **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
+
+## When Not To Use
+
+- If the property chains are very short (single level) and performance is not critical
+- When the object properties are frequently modified, making extraction less beneficial
+- In very simple functions where the overhead of variable extraction outweighs the benefits
+
+## Related Rules
+
+- Consider using this rule alongside other performance-focused rules for optimal AssemblyScript code generation

eslint.config.mjs

@@ -4,10 +4,13 @@ import { baseConfig } from "@schleifner/eslint-config-base/config.mjs";
 
 export default tseslint.config(
   {
-    ignores: [
-      "dist/**",
-      "**/*.mjs",
-    ],
+    ignores: ["dist/**", "**/*.mjs"],
   },
-  ...baseConfig
+  ...baseConfig,
+  {
+    files: ["**/*.ts"],
+    rules: {
+      curly: ["error", "all"]
+    },
+  }
 );

package-lock.json

@@ -56,6 +56,7 @@
     "mocha": "^11.2.2",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.5.3",
+    "ts-node": "^10.9.2",
     "tsx": "^4.19.3"
   },
   "dependencies": {