eslint-plugin-performance-rules 1.0.1

package/README.md

@@ -0,0 +1,197 @@
+# eslint-plugin-performance
+
+ESLint plugin to detect performance anti-patterns in JavaScript and TypeScript codebases. This plugin helps identify code patterns that may cause runtime performance degradation through static AST analysis.
+
+## Features
+
+- 🔍 Detects quadratic loop complexity (O(n²) patterns)
+- 🚫 Identifies synchronous blocking calls in loops
+- ⚡ Catches expensive JSON parsing in loops
+- ⚛️ Finds React inline object creation causing re-renders
+- 🎯 Detects unnecessary array cloning
+- 📊 Performance score formatter with impact assessment
+- 🔧 Works with JavaScript and TypeScript
+- ✅ Zero runtime dependencies
+
+## Installation
+
+```bash
+npm install eslint-plugin-performance --save-dev
+```
+
+## Configuration
+
+### ESLint Configuration (.eslintrc.json)
+
+```json
+{
+  "plugins": ["performance"],
+  "extends": ["plugin:performance/recommended"]
+}
+```
+
+Or configure rules individually:
+
+```json
+{
+  "plugins": ["performance"],
+  "rules": {
+    "performance/no-quadratic-loops": "warn",
+    "performance/no-sync-in-loop": "warn",
+    "performance/no-large-json-parse-in-loop": "warn",
+    "performance/react-no-inline-object-creation": "warn",
+    "performance/no-unnecessary-array-clone": "warn"
+  }
+}
+```
+
+### Flat Config (eslint.config.js)
+
+```javascript
+const performancePlugin = require('eslint-plugin-performance');
+
+module.exports = [
+  {
+    plugins: {
+      performance: performancePlugin
+    },
+    rules: {
+      'performance/no-quadratic-loops': 'warn',
+      'performance/no-sync-in-loop': 'warn',
+      'performance/no-large-json-parse-in-loop': 'warn',
+      'performance/react-no-inline-object-creation': 'warn',
+      'performance/no-unnecessary-array-clone': 'warn'
+    }
+  }
+];
+```
+
+Or use the recommended configuration:
+
+```javascript
+const performancePlugin = require('eslint-plugin-performance');
+
+module.exports = [
+  {
+    plugins: {
+      performance: performancePlugin
+    },
+    rules: performancePlugin.configs.recommended.rules
+  }
+];
+```
+
+### TypeScript Configuration
+
+For TypeScript projects, configure the parser:
+
+**.eslintrc.json:**
+
+```json
+{
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "jsx": true
+    }
+  },
+  "plugins": ["performance"],
+  "extends": ["plugin:performance/recommended"]
+}
+```
+
+**eslint.config.js:**
+
+```javascript
+const performancePlugin = require('eslint-plugin-performance');
+const tsParser = require('@typescript-eslint/parser');
+
+module.exports = [
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        ecmaFeatures: {
+          jsx: true
+        }
+      }
+    },
+    plugins: {
+      performance: performancePlugin
+    },
+    rules: performancePlugin.configs.recommended.rules
+  }
+];
+```
+
+## Rules
+
+### no-quadratic-loops
+Detects nested loops that iterate over the same array reference, which causes O(n²) algorithmic complexity.
+
+**Rationale:** Nested loops over the same array create quadratic time complexity, causing exponential performance degradation as data size grows. A 1000-item array becomes 1,000,000 iterations. Detects synchronous blocking calls (fs.*Sync, child_process.*Sync) inside loops that block the event loop repeatedly.
+
+**Rationale:** Synchronous file system and process operations block the Node.js event loop. Calling them in a loop multiplies the blocking time, freezing your application for extended periods.
+
+### no-large-json-parse-in-loop
+Detects JSON.parse() calls inside loops, which causes repeated expensive parsing operations.
+
+**Rationale:** JSON parsing is CPU-intensive. Parsing JSON repeatedly in a loop wastes processing time. Parse once before the loop or restructure your data flow.
+
+### react-no-inline-object-creation
+Detects inline object literals, array literals, and arrow functions in JSX props that cause unnecessary re-renders.
+
+**Rationale:** Creating new objects, arrays, or functions inline in JSX creates a new reference on every render. This causes child components to re-render even when the actual values haven't changed, breaking React's reconciliation optimization.
+
+
+### no-unnecessary-array-clone
+
+Detects array cloning operations (spread operator, Array.from(), slice()) when the cloned array is never mutated.
+
+**Rationale:** Cloning arrays allocates new memory and copies all elements. If you never mutate the clone, you're wasting memory and CPU cycles. Use the original array reference instead.
+
+## Usage
+
+### Running ESLint
+```bash
+# Standard ESLint run
+npx eslint .
+
+# With auto-fix (where applicable)
+npx eslint . --fix
+
+# Check specific files
+npx eslint src/**/*.js
+```
+
+### Example CLI Output
+
+```
+/project/src/utils/data.js
+  12:3  warning  Nested loop iterates over same array, causing O(n²) complexity  performance/no-quadratic-loops
+  28:5  warning  Synchronous blocking call inside loop blocks event loop         performance/no-sync-in-loop
+
+/project/src/components/UserList.jsx
+  15:23  warning  Inline object creation in JSX prop causes re-renders  performance/react-no-inline-object-creation
+  16:21  warning  Inline arrow function in JSX prop causes re-renders   performance/react-no-inline-object-creation
+
+✖ 4 problems (0 errors, 4 warnings)
+```
+
+### Performance Formatter
+
+Use the custom performance formatter to get an aggregated performance score:
+```bash
+npx eslint . --format ./node_modules/eslint-plugin-performance/lib/formatters/performance.js
+```
+
+## Contributing
+Contributions are welcome! Please open an issue or submit a pull request on GitHub.
+
+## License
+MIT

package/index.js

@@ -0,0 +1,21 @@
+module.exports = {
+  rules: {
+    'no-quadratic-loops': require('./lib/rules/no-quadratic-loops'),
+    'no-sync-in-loop': require('./lib/rules/no-sync-in-loop'),
+    'no-large-json-parse-in-loop': require('./lib/rules/no-large-json-parse-in-loop'),
+    'react-no-inline-object-creation': require('./lib/rules/react-no-inline-object-creation'),
+    'no-unnecessary-array-clone': require('./lib/rules/no-unnecessary-array-clone')
+  },
+  configs: {
+    recommended: {
+      plugins: ['performance'],
+      rules: {
+        'performance/no-quadratic-loops': 'warn',
+        'performance/no-sync-in-loop': 'warn',
+        'performance/no-large-json-parse-in-loop': 'warn',
+        'performance/react-no-inline-object-creation': 'warn',
+        'performance/no-unnecessary-array-clone': 'warn'
+      }
+    }
+  }
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "eslint-plugin-performance-rules",
+  "version": "1.0.1",
+  "description": "ESLint plugin to detect performance anti-patterns",
+  "main": "index.js",
+
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint ."
+  },
+
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "performance",
+    "optimization",
+    "react",
+    "nodejs"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "eslint": ">=7.0.0"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/parser": "^8.56.1",
+    "eslint": "^10.0.2",
+    "typescript": "^5.9.3"
+  }
+}

package/src/lib/formatters/performance.js

@@ -0,0 +1,30 @@
+module.exports = function(results) {
+  // Implementation will be added in Task 8
+  let score = 100;
+  let issueCount = 0;
+
+  for (const result of results) {
+    for (const message of result.messages) {
+      issueCount++;
+      if (message.severity === 1) {
+        score -= 2;
+      } else if (message.severity === 2) {
+        score -= 5;
+      }
+    }
+  }
+
+  score = Math.max(0, score);
+
+  const pointsDeducted = 100 - score;
+  let impact;
+  if (pointsDeducted <= 10) {
+    impact = 'Low';
+  } else if (pointsDeducted <= 30) {
+    impact = 'Medium';
+  } else {
+    impact = 'High';
+  }
+
+  return `Performance Score: ${score}/100\nIssues Found: ${issueCount}\nEstimated Impact: ${impact}\n`;
+};

package/src/lib/rules/no-large-json-parse-in-loop.js

@@ -0,0 +1,109 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect JSON.parse() calls inside loops',
+      category: 'performance',
+      recommended: true
+    },
+    schema: []
+  },
+  create(context) {
+    let loopDepth = 0;
+
+    /**
+     * Check if a CallExpression node is a JSON.parse call
+     * @param {ASTNode} node - The CallExpression node
+     * @returns {boolean} - True if it's a JSON.parse call
+     */
+    function isJSONParse(node) {
+      const { callee } = node;
+      
+      // Must be a MemberExpression (e.g., JSON.parse)
+      if (!callee || callee.type !== 'MemberExpression') {
+        return false;
+      }
+
+      // Get the object and property nodes
+      const objectNode = callee.object;
+      const propertyNode = callee.property;
+
+      // Check for JSON.parse pattern
+      if (objectNode.type === 'Identifier' && propertyNode.type === 'Identifier') {
+        const objectName = objectNode.name;
+        const propertyName = propertyNode.name;
+
+        if (objectName === 'JSON' && propertyName === 'parse') {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Handle loop entry - increment depth counter
+     */
+    function onLoopEnter() {
+      loopDepth++;
+    }
+
+    /**
+     * Handle loop exit - decrement depth counter
+     */
+    function onLoopExit() {
+      loopDepth--;
+    }
+
+    return {
+      // Traditional loop statements
+      ForStatement: onLoopEnter,
+      'ForStatement:exit': onLoopExit,
+      
+      ForOfStatement: onLoopEnter,
+      'ForOfStatement:exit': onLoopExit,
+      
+      ForInStatement: onLoopEnter,
+      'ForInStatement:exit': onLoopExit,
+      
+      WhileStatement: onLoopEnter,
+      'WhileStatement:exit': onLoopExit,
+      
+      DoWhileStatement: onLoopEnter,
+      'DoWhileStatement:exit': onLoopExit,
+
+      // Array method calls (forEach, map, filter, etc.)
+      CallExpression(node) {
+        // Check if this is an array method that acts as a loop
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopEnter();
+          }
+        }
+
+        // Check for JSON.parse calls inside loops
+        if (loopDepth > 0 && isJSONParse(node)) {
+          context.report({
+            node,
+            message: 'JSON.parse() inside loop causes repeated expensive parsing operations'
+          });
+        }
+      },
+      
+      'CallExpression:exit'(node) {
+        // Handle array method exit
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopExit();
+          }
+        }
+      }
+    };
+  }
+};

package/src/lib/rules/no-quadratic-loops.js

@@ -0,0 +1,172 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect nested loops iterating over the same array reference',
+      category: 'performance',
+      recommended: true
+    },
+    schema: []
+  },
+  create(context) {
+    const loopStack = [];
+
+    /**
+     * Extract the iteration target from a loop node
+     * @param {ASTNode} node - The loop node
+     * @returns {ASTNode|null} - The iteration target node or null
+     */
+    function extractIterationTarget(node) {
+      switch (node.type) {
+        case 'ForOfStatement':
+        case 'ForInStatement':
+          // for (item of array) or for (key in object)
+          return node.right;
+
+        case 'ForStatement':
+          // for (let i = 0; i < array.length; i++)
+          // Look for array.length pattern in the test condition
+          if (node.test && node.test.type === 'BinaryExpression') {
+            const { left, right } = node.test;
+            
+            // Check if right side is array.length
+            if (right && right.type === 'MemberExpression' && 
+                right.property && right.property.name === 'length') {
+              return right.object;
+            }
+            
+            // Check if left side is array.length
+            if (left && left.type === 'MemberExpression' && 
+                left.property && left.property.name === 'length') {
+              return left.object;
+            }
+          }
+          return null;
+
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+          // While loops are harder to analyze, skip for now
+          return null;
+
+        case 'CallExpression':
+          // array.forEach(), array.map(), etc.
+          if (node.callee && node.callee.type === 'MemberExpression') {
+            const methodName = node.callee.property.name;
+            const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+            
+            if (arrayMethods.includes(methodName)) {
+              return node.callee.object;
+            }
+          }
+          return null;
+
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Check if two AST nodes represent the same reference
+     * @param {ASTNode} node1 - First node
+     * @param {ASTNode} node2 - Second node
+     * @returns {boolean} - True if they represent the same reference
+     */
+    function isSameReference(node1, node2) {
+      if (!node1 || !node2) {
+        return false;
+      }
+
+      // Both are simple identifiers
+      if (node1.type === 'Identifier' && node2.type === 'Identifier') {
+        return node1.name === node2.name;
+      }
+
+      // Both are member expressions (e.g., obj.arr)
+      if (node1.type === 'MemberExpression' && node2.type === 'MemberExpression') {
+        return isSameReference(node1.object, node2.object) &&
+               isSameReference(node1.property, node2.property);
+      }
+
+      return false;
+    }
+
+    /**
+     * Check if the current loop iterates over the same reference as any outer loop
+     * @param {ASTNode} target - The iteration target of the current loop
+     * @returns {boolean} - True if a match is found
+     */
+    function checkForQuadraticPattern(target) {
+      for (const outerLoop of loopStack) {
+        if (isSameReference(target, outerLoop.target)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    /**
+     * Handle loop entry
+     * @param {ASTNode} node - The loop node
+     */
+    function onLoopEnter(node) {
+      const target = extractIterationTarget(node);
+      
+      if (target && checkForQuadraticPattern(target)) {
+        context.report({
+          node,
+          message: 'Nested loop iterates over the same array reference, causing O(n²) complexity'
+        });
+      }
+
+      loopStack.push({ node, target });
+    }
+
+    /**
+     * Handle loop exit
+     */
+    function onLoopExit() {
+      loopStack.pop();
+    }
+
+    return {
+      // Traditional loop statements
+      ForStatement: onLoopEnter,
+      'ForStatement:exit': onLoopExit,
+      
+      ForOfStatement: onLoopEnter,
+      'ForOfStatement:exit': onLoopExit,
+      
+      ForInStatement: onLoopEnter,
+      'ForInStatement:exit': onLoopExit,
+      
+      WhileStatement: onLoopEnter,
+      'WhileStatement:exit': onLoopExit,
+      
+      DoWhileStatement: onLoopEnter,
+      'DoWhileStatement:exit': onLoopExit,
+
+      // Array method calls (forEach, map, filter, etc.)
+      CallExpression(node) {
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopEnter(node);
+          }
+        }
+      },
+      
+      'CallExpression:exit'(node) {
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopExit();
+          }
+        }
+      }
+    };
+  }
+};

package/src/lib/rules/no-sync-in-loop.js

@@ -0,0 +1,115 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect synchronous blocking calls inside loops',
+      category: 'performance',
+      recommended: true
+    },
+    schema: []
+  },
+  create(context) {
+    let loopDepth = 0;
+
+    /**
+     * Check if a CallExpression node is a blocking synchronous call
+     * @param {ASTNode} node - The CallExpression node
+     * @returns {boolean} - True if it's a blocking call
+     */
+    function isBlockingCall(node) {
+      const { callee } = node;
+      
+      // Must be a MemberExpression (e.g., fs.readFileSync, child_process.execSync)
+      if (!callee || callee.type !== 'MemberExpression') {
+        return false;
+      }
+
+      // Get the object and property names
+      const objectNode = callee.object;
+      const propertyNode = callee.property;
+
+      // Handle simple cases: fs.readFileSync, child_process.execSync
+      if (objectNode.type === 'Identifier' && propertyNode.type === 'Identifier') {
+        const objectName = objectNode.name;
+        const propertyName = propertyNode.name;
+
+        // Check for fs.*Sync patterns
+        if (objectName === 'fs' && propertyName.endsWith('Sync')) {
+          return true;
+        }
+
+        // Check for child_process.*Sync patterns
+        if (objectName === 'child_process' && propertyName.endsWith('Sync')) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Handle loop entry - increment depth counter
+     */
+    function onLoopEnter() {
+      loopDepth++;
+    }
+
+    /**
+     * Handle loop exit - decrement depth counter
+     */
+    function onLoopExit() {
+      loopDepth--;
+    }
+
+    return {
+      // Traditional loop statements
+      ForStatement: onLoopEnter,
+      'ForStatement:exit': onLoopExit,
+      
+      ForOfStatement: onLoopEnter,
+      'ForOfStatement:exit': onLoopExit,
+      
+      ForInStatement: onLoopEnter,
+      'ForInStatement:exit': onLoopExit,
+      
+      WhileStatement: onLoopEnter,
+      'WhileStatement:exit': onLoopExit,
+      
+      DoWhileStatement: onLoopEnter,
+      'DoWhileStatement:exit': onLoopExit,
+
+      // Array method calls (forEach, map, filter, etc.)
+      CallExpression(node) {
+        // Check if this is an array method that acts as a loop
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopEnter();
+          }
+        }
+
+        // Check for blocking calls inside loops
+        if (loopDepth > 0 && isBlockingCall(node)) {
+          context.report({
+            node,
+            message: 'Synchronous blocking call inside loop blocks the event loop repeatedly'
+          });
+        }
+      },
+      
+      'CallExpression:exit'(node) {
+        // Handle array method exit
+        if (node.callee && node.callee.type === 'MemberExpression') {
+          const methodName = node.callee.property.name;
+          const arrayMethods = ['forEach', 'map', 'filter', 'reduce', 'some', 'every', 'find'];
+          
+          if (arrayMethods.includes(methodName)) {
+            onLoopExit();
+          }
+        }
+      }
+    };
+  }
+};

package/src/lib/rules/no-unnecessary-array-clone.js

@@ -0,0 +1,156 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect array cloning when the cloned array is never mutated',
+      category: 'performance',
+      recommended: true
+    },
+    schema: []
+  },
+  create(context) {
+    /**
+     * Check if a node represents an array cloning pattern
+     * @param {ASTNode} node - The node to check
+     * @returns {boolean} - True if it's a cloning pattern
+     */
+    function isCloningPattern(node) {
+      if (!node) {
+        return false;
+      }
+
+      // Pattern 1: Spread operator [...arr]
+      if (node.type === 'ArrayExpression' &&
+          node.elements.length === 1 &&
+          node.elements[0] &&
+          node.elements[0].type === 'SpreadElement') {
+        return true;
+      }
+
+      // Pattern 2: Array.from(arr)
+      if (node.type === 'CallExpression' &&
+          node.callee &&
+          node.callee.type === 'MemberExpression' &&
+          node.callee.object &&
+          node.callee.object.type === 'Identifier' &&
+          node.callee.object.name === 'Array' &&
+          node.callee.property &&
+          node.callee.property.name === 'from') {
+        return true;
+      }
+
+      // Pattern 3: arr.slice() with no arguments
+      if (node.type === 'CallExpression' &&
+          node.callee &&
+          node.callee.type === 'MemberExpression' &&
+          node.callee.property &&
+          node.callee.property.name === 'slice' &&
+          node.arguments.length === 0) {
+        return true;
+      }
+
+      return false;
+    }
+
+    /**
+     * Check if a reference represents a mutation
+     * @param {Reference} reference - The variable reference to check
+     * @returns {boolean} - True if it's a mutating reference
+     */
+    function isMutatingReference(reference) {
+      const identifier = reference.identifier;
+      const parent = identifier.parent;
+
+      if (!parent) {
+        return false;
+      }
+
+      // Pattern 1: Assignment expression (clone[0] = value)
+      if (parent.type === 'AssignmentExpression' && parent.left === identifier) {
+        return true;
+      }
+
+      // Pattern 2: Member expression for array index assignment (clone[0] = value)
+      if (parent.type === 'MemberExpression' && parent.object === identifier) {
+        const grandparent = parent.parent;
+        
+        // Check if the member expression is on the left side of an assignment
+        if (grandparent && 
+            grandparent.type === 'AssignmentExpression' && 
+            grandparent.left === parent) {
+          return true;
+        }
+
+        // Check if it's a mutating method call
+        if (grandparent && grandparent.type === 'CallExpression') {
+          const methodName = parent.property.name;
+          const mutatingMethods = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'];
+          
+          if (mutatingMethods.includes(methodName)) {
+            return true;
+          }
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Check if a variable is mutated in its scope
+     * @param {Variable} variable - The variable to check
+     * @returns {boolean} - True if the variable is mutated
+     */
+    function isVariableMutated(variable) {
+      if (!variable || !variable.references) {
+        return false;
+      }
+
+      // Check all references to the variable
+      for (const reference of variable.references) {
+        // Skip the initial declaration/write
+        if (reference.init) {
+          continue;
+        }
+
+        if (isMutatingReference(reference)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    return {
+      VariableDeclarator(node) {
+        // Check if this is a cloning pattern
+        if (!isCloningPattern(node.init)) {
+          return;
+        }
+
+        // Get the variable name
+        if (!node.id || node.id.type !== 'Identifier') {
+          return;
+        }
+
+        const variableName = node.id.name;
+
+        // Get the scope and find the variable
+        const sourceCode = context.sourceCode || context.getSourceCode();
+        const scope = sourceCode.getScope(node);
+        const variable = scope.set.get(variableName);
+
+        if (!variable) {
+          return;
+        }
+
+        // Check if the variable is mutated
+        if (!isVariableMutated(variable)) {
+          context.report({
+            node,
+            message: 'Unnecessary array clone - array is never mutated'
+          });
+        }
+      }
+    };
+  }
+};

package/src/lib/rules/react-no-inline-object-creation.js

@@ -0,0 +1,81 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect inline object, array, and function creation in JSX props',
+      category: 'performance',
+      recommended: true
+    },
+    schema: []
+  },
+  create(context) {
+    /**
+     * Check if an expression is an inline creation pattern
+     * @param {ASTNode} expression - The expression node to check
+     * @returns {string|null} - The type of inline creation or null
+     */
+    function getInlineCreationType(expression) {
+      if (!expression) {
+        return null;
+      }
+
+      switch (expression.type) {
+        case 'ObjectExpression':
+          return 'object';
+        
+        case 'ArrayExpression':
+          return 'array';
+        
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression':
+          return 'function';
+        
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Get appropriate message for the inline creation type
+     * @param {string} type - The type of inline creation
+     * @returns {string} - The warning message
+     */
+    function getMessage(type) {
+      switch (type) {
+        case 'object':
+          return 'Inline object creation in JSX prop causes unnecessary re-renders';
+        
+        case 'array':
+          return 'Inline array creation in JSX prop causes unnecessary re-renders';
+        
+        case 'function':
+          return 'Inline function creation in JSX prop causes unnecessary re-renders';
+        
+        default:
+          return 'Inline creation in JSX prop causes unnecessary re-renders';
+      }
+    }
+
+    return {
+      JSXAttribute(node) {
+        // Check if the attribute has a value
+        if (!node.value) {
+          return;
+        }
+
+        // Check if the value is a JSXExpressionContainer
+        if (node.value.type === 'JSXExpressionContainer') {
+          const expression = node.value.expression;
+          const creationType = getInlineCreationType(expression);
+
+          if (creationType) {
+            context.report({
+              node: node.value,
+              message: getMessage(creationType)
+            });
+          }
+        }
+      }
+    };
+  }
+};