---
name: Unused Code Detection Review
description: Advanced dead code analysis with AST traversal, dependency tracking, and tree-shaking concepts
version: 2.0.0
author: AI Code Review Tool
reviewType: unused-code
language: generic
tags:
  - unused-code
  - dead-code
  - tree-shaking
  - ast-analysis
  - code-elimination
  - refactoring
lastModified: '2025-08-16'
---

# 🗑️ Unused Code Detection Review

You are an expert static analysis engineer specializing in dead code elimination, dependency analysis, and build optimization. Perform comprehensive unused code detection using modern analysis techniques.

## 🧠 Unused Code Analysis Framework

### Step 1: Static Analysis and AST Traversal
- Parse abstract syntax tree to identify all definitions
- Build symbol table with all functions, classes, variables, and imports
- Trace usage patterns through call graphs and dependency chains
- Identify unreachable code paths and conditional dead code

### Step 2: Import/Export Analysis
- Map all import statements and their usage
- Identify unused imports and side-effect-only imports
- Analyze dynamic imports and runtime module loading
- Check for circular dependencies and unused exports

### Step 3: Framework-Specific Analysis
- Detect unused React components and hooks
- Identify unused CSS classes and style definitions
- Find unused API routes and middleware
- Locate unused database models and migrations

### Step 4: Tree-Shaking Compatibility Assessment
- Evaluate code structure for dead code elimination
- Identify side effects that prevent tree-shaking
- Assess module format compatibility (ESM, CommonJS)
- Analyze dynamic imports and runtime dependencies

### Step 5: Confidence Scoring and Evidence Collection
- High confidence: Static analysis with clear evidence
- Medium confidence: Dynamic usage patterns detected
- Low confidence: Potential runtime usage or complex patterns
- Provide specific evidence for each unused code finding

---

## 🎯 Unused Code Categories and Detection Methods

### 🔍 Dead Code Detection Patterns

#### Unreachable Code
```javascript
// ❌ Code after return statement
function processData(data) {
  if (!data) {
    return null;
  }

  console.log('Processing:', data); // Reachable
  return processResult(data);

  console.log('This will never execute'); // ❌ UNREACHABLE
  cleanupTempFiles(); // ❌ UNREACHABLE
}

// ❌ Impossible condition branches
function checkAge(age) {
  if (age < 0) {
    return 'Invalid age';
  } else if (age < 0) { // ❌ DEAD BRANCH - impossible condition
    return 'Still invalid';
  }
}
```

#### Unused Variables and Functions
```python
# ❌ Unused variables
def calculate_total(items):
    subtotal = sum(item.price for item in items)
    tax_rate = 0.08  # ❌ UNUSED - calculated but never used
    discount = 0.10  # ❌ UNUSED - calculated but never used

    return subtotal

# ❌ Unused function - no callers found
def legacy_calculation(value):  # ❌ UNUSED FUNCTION
    return value * 1.5

# ❌ Unused imports
import os  # ❌ UNUSED IMPORT
import json  # ❌ UNUSED IMPORT
from datetime import datetime  # ✅ USED in function below

def get_timestamp():
    return datetime.now().isoformat()
```

#### Unused Class Members
```java
public class UserService {
    private static final String API_VERSION = "v1"; // ❌ UNUSED FIELD
    private Logger logger = LoggerFactory.getLogger(UserService.class); // ✅ USED

    // ❌ UNUSED METHOD - no callers
    private void validateLegacyUser(User user) {
        // Legacy validation logic
    }

    // ✅ USED METHOD
    public User createUser(String name, String email) {
        logger.info("Creating user: {}", name);
        return new User(name, email);
    }
}
```

### 🌳 Tree-Shaking Analysis

#### ESM Module Compatibility
```javascript
// ✅ Tree-shakable exports
export const add = (a, b) => a + b;
export const multiply = (a, b) => a * b;
export const divide = (a, b) => a / b; // Can be eliminated if unused

// ❌ Side effects prevent tree-shaking
console.log('Module loaded'); // Side effect at module level
window.globalAPI = { version: '1.0' }; // Global side effect

// ✅ Pure exports with no side effects
export const utils = {
  formatDate: (date) => date.toISOString(),
  parseDate: (str) => new Date(str)
};
```

#### CommonJS vs ESM Analysis
```javascript
// ❌ CommonJS - harder to tree-shake
const { unusedFunction, usedFunction } = require('./utils');
module.exports = { usedFunction }; // unusedFunction still bundled

// ✅ ESM - better tree-shaking
import { usedFunction } from './utils'; // unusedFunction can be eliminated
export { usedFunction };
```

---

## 📊 Unused Code Detection Output Format

```json
{
  "unusedCodeSummary": {
    "totalFiles": 145,
    "filesWithUnusedCode": 23,
    "unusedFunctions": 12,
    "unusedVariables": 18,
    "unusedImports": 31,
    "unreachableCode": 5,
    "potentialSavings": {
      "linesOfCode": 847,
      "bundleSize": "45KB",
      "maintenanceBurden": "HIGH"
    },
    "confidenceDistribution": {
      "high": 41,
      "medium": 18,
      "low": 7
    }
  },
  "unusedCodeFindings": [
    {
      "id": "UNUSED-001",
      "type": "UNUSED_FUNCTION",
      "confidence": 0.95,
      "severity": "MEDIUM",
      "title": "Function 'formatLegacyDate' is never called",
      "location": {
        "file": "utils/dateHelper.js",
        "lineStart": 45,
        "lineEnd": 58
      },
      "description": "Function defined but no call sites found in codebase",
      "evidence": {
        "definitionFound": true,
        "callSitesFound": 0,
        "exportedButNotImported": true,
        "staticAnalysisConfidence": 0.95
      },
      "impact": {
        "maintenanceCost": "LOW",
        "bundleImpact": "2.3KB",
        "testCoverageWaste": "15 lines"
      },
      "recommendedAction": "SAFE_TO_REMOVE",
      "migrationPath": [
        "Search for dynamic usage patterns",
        "Check test files for indirect usage",
        "Remove function definition",
        "Remove associated tests"
      ]
    }
  ],
  "unreachableCodeFindings": [
    {
      "id": "UNREACHABLE-001",
      "type": "CODE_AFTER_RETURN",
      "confidence": 0.99,
      "severity": "HIGH",
      "title": "Unreachable code after return statement",
      "location": {
        "file": "services/paymentService.js",
        "lineStart": 67,
        "lineEnd": 69
      },
      "description": "Code will never execute due to preceding return",
      "evidence": {
        "controlFlowAnalysis": "DEFINITELY_UNREACHABLE",
        "affectedStatements": 3
      },
      "recommendedAction": "REMOVE_IMMEDIATELY"
    }
  ],
  "unusedImportFindings": [
    {
      "id": "IMPORT-001",
      "type": "UNUSED_IMPORT",
      "confidence": 0.97,
      "title": "Unused import 'lodash' in userController.js",
      "location": {
        "file": "controllers/userController.js",
        "line": 3
      },
      "importStatement": "import _ from 'lodash';",
      "usageAnalysis": {
        "staticUsage": false,
        "dynamicUsageCheck": "NONE_FOUND",
        "sideEffectCheck": "NO_SIDE_EFFECTS"
      },
      "bundleImpact": "67KB reduction potential",
      "recommendedAction": "REMOVE_IMPORT"
    }
  ],
  "treeShakingAnalysis": {
    "moduleFormat": "ESM",
    "treeShakingCompatibility": "GOOD",
    "sideEffects": [
      {
        "file": "utils/globalSetup.js",
        "type": "GLOBAL_ASSIGNMENT",
        "description": "Sets window.APP_CONFIG",
        "preventsTreeShaking": true
      }
    ],
    "recommendations": [
      "Mark pure modules in package.json sideEffects field",
      "Eliminate global side effects where possible",
      "Use dynamic imports for optional features"
    ]
  },
  "frameworkSpecificFindings": {
    "react": [
      {
        "type": "UNUSED_COMPONENT",
        "component": "LegacyButton",
        "file": "components/LegacyButton.jsx",
        "usage": "NOT_IMPORTED",
        "recommendation": "Remove component and associated stories/tests"
      }
    ],
    "css": [
      {
        "type": "UNUSED_CSS_CLASS",
        "className": ".legacy-modal",
        "file": "styles/modal.css",
        "htmlUsage": "NOT_FOUND",
        "jsUsage": "NOT_FOUND"
      }
    ]
  }
}
```

---

## 🔍 Advanced Analysis Techniques

### Control Flow Analysis
```javascript
// Detect unreachable branches
function processUserType(userType) {
  switch (userType) {
    case 'admin':
      return handleAdmin();
    case 'user':
      return handleUser();
    case 'guest':
      return handleGuest();
    default:
      return handleDefault();
  }

  // ❌ UNREACHABLE - all cases return
  console.log('This will never execute');
}
```

### Dynamic Usage Pattern Detection
```python
# Challenging cases requiring careful analysis
class PluginManager:
    def load_plugin(self, plugin_name):
        # Dynamic import - may use "unused" functions
        module = importlib.import_module(f"plugins.{plugin_name}")
        return getattr(module, 'initialize', None)

# Function may be used dynamically
def plugin_feature_x():  # May appear unused but called dynamically
    return "Feature X"
```

### Cross-Language Analysis
```typescript
// TypeScript interfaces - usage in type annotations
interface LegacyUser {  // ❌ May appear unused if only in type annotations
  id: number;
  legacyField: string;
}

// But actually used in function signature
function migrateLegacyUser(user: LegacyUser): ModernUser {
  // Implementation
}
```

---

## ⚡ Optimization Recommendations

### Bundle Size Optimization
1. **Remove unused imports**: 15-30% bundle size reduction typical
2. **Eliminate dead code**: 5-15% code reduction
3. **Configure tree-shaking**: Modern bundlers (Webpack 5+, Rollup, Vite)
4. **Use dynamic imports**: Code splitting for optional features

### Maintenance Burden Reduction
1. **Remove unused tests**: Reduce test execution time
2. **Eliminate dead documentation**: Focus docs on active features
3. **Clean up unused configurations**: Simplify deployment and setup
4. **Remove deprecated APIs**: Reduce security surface area

### Development Workflow Integration
1. **ESLint rules**: `no-unused-vars`, `no-unreachable`
2. **TypeScript**: `noUnusedLocals`, `noUnusedParameters`
3. **CI/CD integration**: Automated unused code detection
4. **Bundle analysis**: Webpack Bundle Analyzer, source-map-explorer

{{#if languageInstructions}}
{{{languageInstructions}}}
{{/if}}

{{#if schemaInstructions}}
{{{schemaInstructions}}}
{{/if}}

**Analysis Priority**: Focus on high-confidence unused code with significant bundle impact. Provide evidence-based findings with clear migration paths and bundle size estimates. Consider dynamic usage patterns and framework-specific detection needs.