feat(rules): add prefer-optional-chain rule ❓

- Add complete test coverage with 35 test cases
- Add prefer-optional-chain lint rule implementation
- Add detailed documentation and examples for the new rule
- Add new AST node types for conditional and member expressions
- Add new type guards for improved type safety
- Reorganize type definitions and utilities alphabetically
- Refactor existing code for better maintainability
- Update module exports to include new rule

Author: NeaByteLab

README.md

@@ -8,6 +8,7 @@ Deno lint plugin collection for identifying and reporting on patterns found in c
 - [`explicit-parameter-types`](./examples/explicit-parameter-types.md) - Requires explicit type annotations on parameters
 - [`explicit-return-types`](./examples/explicit-return-types.md) - Requires explicit return type annotations
 - [`prefer-nullish-coalescing`](./examples/prefer-nullish-coalescing.md) - Prefers nullish coalescing (??) over logical OR (||) for null/undefined checks
+- [`prefer-optional-chain`](./examples/prefer-optional-chain.md) - Prefers optional chaining (?.) over logical AND (&&) for property access
 - [`require-error-handling`](./examples/require-error-handling.md) - Ensures Deno file operations are properly awaited
 
 ## Installation

examples/prefer-optional-chain.md

@@ -0,0 +1,187 @@
+# Expected Behavior: `prefer-optional-chain` Rule
+
+This rule enforces the use of optional chaining (`?.`) over logical AND (`&&`) for property access when the same object is being checked and accessed.
+
+## ❌ Invalid Examples
+
+```typescript
+// Logical AND with property access (same object)
+const name = user && user.name
+const email = user && user.profile && user.profile.email
+const count = data && data.items && data.items.length
+
+// Logical AND with method calls (same object)
+const result = api && api.getData()
+const user = service && service.getUser(id)
+const processed = data && data.filter().map()
+
+// Logical AND with computed property access (same object)
+const value = obj && obj[key]
+const item = array && array[index]
+const prop = config && config[setting]
+
+// Complex nested access patterns
+const fullName = user && user.profile && user.profile.name
+const settings = config && config.user && config.user.preferences
+const data = response && response.data && response.data.results
+
+// In function parameters and returns
+function getUserName(user) {
+  return user && user.name
+}
+
+const getUserEmail = user => user && user.profile && user.profile.email
+
+// In object properties
+const userData = {
+  name: user && user.name,
+  email: user && user.profile && user.profile.email
+}
+
+// In template literals
+const greeting = `Hello ${user && user.name}!`
+const status = `Count: ${data && data.items && data.items.length}`
+
+// In class methods
+class UserService {
+  getName(user) {
+    return user && user.name
+  }
+
+  getProfile(user) {
+    return user && user.profile && user.profile.details
+  }
+}
+
+// In async functions
+async function fetchUserData(id) {
+  const user = await api.getUser(id)
+  return user && user.profile && user.profile.email
+}
+```
+
+## ✅ Valid Examples
+
+```typescript
+// Optional chaining with property access (correct)
+const name = user?.name
+const email = user?.profile?.email
+const count = data?.items?.length
+
+// Optional chaining with method calls (correct)
+const result = api?.getData()
+const user = service?.getUser(id)
+const processed = data?.filter()?.map()
+
+// Optional chaining with computed property access (correct)
+const value = obj?.[key]
+const item = array?.[index]
+const prop = config?.[setting]
+
+// Complex nested access patterns with optional chaining
+const fullName = user?.profile?.name
+const settings = config?.user?.preferences
+const data = response?.data?.results
+
+// In function parameters and returns
+function getUserName(user) {
+  return user?.name
+}
+
+const getUserEmail = user => user?.profile?.email
+
+// In object properties
+const userData = {
+  name: user?.name,
+  email: user?.profile?.email
+}
+
+// In template literals
+const greeting = `Hello ${user?.name}!`
+const status = `Count: ${data?.items?.length}`
+
+// In class methods
+class UserService {
+  getName(user) {
+    return user?.name
+  }
+
+  getProfile(user) {
+    return user?.profile?.details
+  }
+}
+
+// In async functions
+async function fetchUserData(id) {
+  const user = await api.getUser(id)
+  return user?.profile?.email
+}
+
+// Logical AND with different objects (not affected by this rule)
+const result = user && profile.name
+const data = api && otherService.getData()
+
+// Logical AND with literals (not affected by this rule)
+const flag = user && 'active'
+const message = data && 'loaded'
+
+// Logical AND with function calls (not affected by this rule)
+const result = user && getName()
+const data = api && processData()
+
+// Already using optional chaining (not affected by this rule)
+const name = user?.name
+const email = user?.profile?.email
+
+// Logical OR (not affected by this rule)
+const name = user || user.name
+const email = user || user.profile?.email
+```
+
+## Rule Scope
+
+This rule **only applies to**:
+
+- ✅ Logical AND (`&&`) operators where the same object is being checked and accessed:
+  - `object && object.property` → `object?.property`
+  - `object && object.method()` → `object?.method()`
+  - `object && object[key]` → `object?.[key]`
+
+This rule **does NOT apply to**:
+
+- ❌ Logical AND (`&&`) with different objects (`user && profile.name`)
+- ❌ Logical AND (`&&`) with literals (`user && 'active'`)
+- ❌ Logical AND (`&&`) with function calls (`user && getName()`)
+- ❌ Logical OR (`||`) operators
+- ❌ Already using optional chaining (`user?.name`)
+- ❌ Other logical operators (`!`, `??`)
+
+## Why This Rule Matters
+
+The logical AND (`&&`) pattern for property access is verbose and error-prone:
+
+```typescript
+// ❌ Verbose and repetitive
+const name = user && user.name
+const email = user && user.profile && user.profile.email
+const count = data && data.items && data.items.length
+```
+
+Optional chaining (`?.`) is more concise and readable:
+
+```typescript
+// ✅ Concise and clear
+const name = user?.name
+const email = user?.profile?.email
+const count = data?.items?.length
+```
+
+## Auto-fix Behavior
+
+The rule provides auto-fix suggestions that replace `&&` with `?.`:
+
+- `user && user.name` → `user?.name`
+- `user && user.getName()` → `user?.getName()`
+- `obj && obj[key]` → `obj?.[key]`
+- `api && api.getData(id)` → `api?.getData(id)`
+- `user && user.profile && user.profile.email` → `user?.profile?.email`

src/mod.ts

@@ -3,6 +3,7 @@ import { asyncFunctionNamingRule } from '@rules/async-function-naming.ts'
 import { explicitParameterTypesRule } from '@rules/explicit-parameter-types.ts'
 import { explicitReturnTypesRule } from '@rules/explicit-return-types.ts'
 import { preferNullishCoalescingRule } from '@rules/prefer-nullish-coalescing.ts'
+import { preferOptionalChainRule } from '@rules/prefer-optional-chain.ts'
 import { requireErrorHandlingRule } from '@rules/require-error-handling.ts'
 
 /**
@@ -15,6 +16,7 @@ const plugin: LintPlugin = {
     'explicit-parameter-types': explicitParameterTypesRule,
     'explicit-return-types': explicitReturnTypesRule,
     'prefer-nullish-coalescing': preferNullishCoalescingRule,
+    'prefer-optional-chain': preferOptionalChainRule,
     'require-error-handling': requireErrorHandlingRule
   }
 }

src/rules/prefer-nullish-coalescing.ts

@@ -1,25 +1,6 @@
 import type { ASTNode, LintContext, LintFixer, LogicalExpressionNode } from '@app/types.ts'
 import { isLiteral, isLogicalExpression } from '@shared/expression.ts'
 
-/**
- * Checks if a logical expression should use nullish coalescing instead of logical OR.
- * @param node - The logical expression node to check
- * @returns True if the expression should use nullish coalescing, false otherwise
- */
-function shouldUseNullishCoalescing(node: LogicalExpressionNode): boolean {
-  if (node.operator !== '||') {
-    return false
-  }
-  const rightSide = node.right
-  if (isLiteral(rightSide)) {
-    const value = rightSide.value
-    if (value === '' || value === 0 || value === false) {
-      return true
-    }
-  }
-  return false
-}
-
 /**
  * Lint rule for preferring nullish coalescing over logical OR.
  */
@@ -55,3 +36,22 @@ export const preferNullishCoalescingRule = {
     }
   }
 }
+
+/**
+ * Checks if a logical expression should use nullish coalescing instead of logical OR.
+ * @param node - The logical expression node to check
+ * @returns True if the expression should use nullish coalescing, false otherwise
+ */
+function shouldUseNullishCoalescing(node: LogicalExpressionNode): boolean {
+  if (node.operator !== '||') {
+    return false
+  }
+  const rightSide = node.right
+  if (isLiteral(rightSide)) {
+    const value = rightSide.value
+    if (value === '' || value === 0 || value === false) {
+      return true
+    }
+  }
+  return false
+}