feat(eslint-plugin): [prefer-optional-chain] support logical with empty object

packages/eslint-plugin/docs/rules/prefer-optional-chain.md

@@ -22,6 +22,10 @@ function myFunc(foo: T | null) {
 function myFunc(foo: T | null) {
   return foo && foo.a && foo.a.b && foo.a.b.c;
 }
+// or
+function myFunc(foo: T | null) {
+  return (((foo || {}).a || {}).b || {}).c;
+}
 
 function myFunc(foo: T | null) {
   return foo?.['a']?.b?.c;
@@ -57,6 +61,9 @@ foo && foo.a && foo.a.b && foo.a.b.c;
 foo && foo['a'] && foo['a'].b && foo['a'].b.c;
 foo && foo.a && foo.a.b && foo.a.b.method && foo.a.b.method();
 
+(((foo || {}).a || {}).b {}).c;
+(((foo || {})['a'] || {}).b {}).c;
+
 // this rule also supports converting chained strict nullish checks:
 foo &&
   foo.a != null &&

packages/eslint-plugin/src/rules/prefer-optional-chain.ts

@@ -48,6 +48,59 @@ export default util.createRule({
   create(context) {
     const sourceCode = context.getSourceCode();
     return {
+      'LogicalExpression[operator=||],LogicalExpression[operator=??]'(
+        node: TSESTree.LogicalExpression,
+      ): void {
+        const leftNode = node.left;
+        const rightNode = node.right;
+        const parentNode = node.parent;
+        const isRightNodeAnEmptyObjectLiteral =
+          rightNode.type === AST_NODE_TYPES.ObjectExpression &&
+          rightNode.properties.length === 0;
+        // Ignore nodes that evaluate to numbers or booleans
+        const canLeftNodeBeANullishObject =
+          leftNode.type !== AST_NODE_TYPES.BinaryExpression &&
+          leftNode.type !== AST_NODE_TYPES.UnaryExpression;
+        if (
+          !canLeftNodeBeANullishObject ||
+          !isRightNodeAnEmptyObjectLiteral ||
+          !parentNode ||
+          parentNode.type !== AST_NODE_TYPES.MemberExpression ||
+          parentNode.optional
+        ) {
+          return;
+        }
+        context.report({
+          node: parentNode,
+          messageId: 'optionalChainSuggest',
+          suggest: [
+            {
+              messageId: 'optionalChainSuggest',
+              fix: (fixer): TSESLint.RuleFix => {
+                const leftNodeText = sourceCode.getText(leftNode);
+                // Any node that is made of an operator with higher or equal precedence,
+                // is reasonable to sometimes evaluate as falsy or an object (maybe not bitwise/binary operators)
+                const maybeWrappedLeftNode =
+                  leftNode.type === AST_NODE_TYPES.LogicalExpression ||
+                  leftNode.type === AST_NODE_TYPES.ConditionalExpression ||
+                  leftNode.type === AST_NODE_TYPES.AwaitExpression
+                    ? `(${leftNodeText})`
+                    : leftNodeText;
+                const propertyToBeOptionalText = sourceCode.getText(
+                  parentNode.property,
+                );
+                const maybeWrappedProperty = parentNode.computed
+                  ? `[${propertyToBeOptionalText}]`
+                  : propertyToBeOptionalText;
+                return fixer.replaceTextRange(
+                  parentNode.range,
+                  `${maybeWrappedLeftNode}?.${maybeWrappedProperty}`,
+                );
+              },
+            },
+          ],
+        });
+      },
       [[
         'LogicalExpression[operator="&&"] > Identifier',
         'LogicalExpression[operator="&&"] > MemberExpression',