CommonJS imports support destructuring+property access

Fixes #40578 for prettier

Author: sandersn

src/compiler/checker.ts

@@ -2439,10 +2439,11 @@ namespace ts {
         }
 
         function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration | VariableDeclaration, dontResolveAlias: boolean): Symbol | undefined {
-            if (isVariableDeclaration(node) && node.initializer && isPropertyAccessExpression(node.initializer)) {
-                const name = (getLeftmostAccessExpression(node.initializer.expression) as CallExpression).arguments[0] as StringLiteral;
-                return isIdentifier(node.initializer.name)
-                    ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), node.initializer.name.escapedText))
+            const commonJSPropertyAccess = getCommonJSPropertyAccess(node)
+            if (commonJSPropertyAccess) {
+                const name = (getLeftmostAccessExpression(commonJSPropertyAccess.expression) as CallExpression).arguments[0] as StringLiteral;
+                return isIdentifier(commonJSPropertyAccess.name)
+                    ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), commonJSPropertyAccess.name.escapedText))
                     : undefined;
             }
             if (isVariableDeclaration(node) || node.moduleReference.kind === SyntaxKind.ExternalModuleReference) {
@@ -2637,15 +2638,17 @@ namespace ts {
             return result;
         }
 
-        function getExportOfModule(symbol: Symbol, specifier: ImportOrExportSpecifier | BindingElement, dontResolveAlias: boolean): Symbol | undefined {
+        function getExportOfModule(symbol: Symbol, specifier: ImportOrExportSpecifier | BindingElement | PropertyAccessExpression, dontResolveAlias: boolean): Symbol | undefined {
             if (symbol.flags & SymbolFlags.Module) {
-                const name = specifier.propertyName ?? specifier.name;
+                const name = !isPropertyAccessExpression(specifier) && specifier.propertyName || specifier.name;
                 if (!isIdentifier(name)) {
                     return undefined;
                 }
                 const exportSymbol = getExportsOfSymbol(symbol).get(name.escapedText);
                 const resolved = resolveSymbol(exportSymbol, dontResolveAlias);
-                markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, /*overwriteEmpty*/ false);
+                if (!isPropertyAccessExpression(specifier)) {
+                    markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, /*overwriteEmpty*/ false);
+                }
                 return resolved;
             }
         }
@@ -2659,6 +2662,12 @@ namespace ts {
             }
         }
 
+        function getCommonJSPropertyAccess(node: Node) {
+            if(isVariableDeclaration(node) && node.initializer && isPropertyAccessExpression(node.initializer)) {
+                return node.initializer;
+            }
+        }
+
         function getExternalModuleMember(node: ImportDeclaration | ExportDeclaration | VariableDeclaration, specifier: ImportOrExportSpecifier | BindingElement, dontResolveAlias = false): Symbol | undefined {
             const moduleSpecifier = getExternalModuleRequireArgument(node) || (node as ImportDeclaration | ExportDeclaration).moduleSpecifier!;
             const moduleSymbol = resolveExternalModuleName(node, moduleSpecifier)!; // TODO: GH#18217
@@ -2682,10 +2691,14 @@ namespace ts {
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText);
                     }
-
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias);
-                    let symbolFromModule = getExportOfModule(targetSymbol, specifier, dontResolveAlias);
+
+                    const commonJSPropertyAccess = getCommonJSPropertyAccess(node)
+                    let symbolFromModule = getExportOfModule(targetSymbol, commonJSPropertyAccess || specifier, dontResolveAlias);
+                    if (commonJSPropertyAccess && symbolFromModule) {
+                        symbolFromModule = getPropertyOfType(getTypeOfSymbol(symbolFromModule), name.escapedText);
+                    }
                     if (symbolFromModule === undefined && name.escapedText === InternalSymbolName.Default) {
                         const file = find(moduleSymbol.declarations, isSourceFile);
                         if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias)) {

tests/baselines/reference/jsDeclarationsTypeReferences2.errors.txt

@@ -38,4 +38,4 @@ export declare const o: {
     m: number;
 };
 //// [index.d.ts]
-export const thing: any;
+export const thing: number;

tests/baselines/reference/jsDeclarationsTypeReferences2.js

@@ -1,28 +1,28 @@
 === tests/cases/conformance/jsdoc/declarations/index.js ===
 const{ a, m } = require("./something").o;
->a : any
->m : any
+>a : number
+>m : number
 >require("./something").o : { a: number; m: number; }
 >require("./something") : typeof import("tests/cases/conformance/jsdoc/declarations/something")
 >require : any
 >"./something" : "./something"
 >o : { a: number; m: number; }
 
 const thing = a + m
->thing : any
->a + m : any
->a : any
->m : any
+>thing : number
+>a + m : number
+>a : number
+>m : number
 
 module.exports = {
->module.exports = {    thing} : { thing: any; }
->module.exports : { thing: any; }
->module : { "\"tests/cases/conformance/jsdoc/declarations/index\"": { thing: any; }; }
->exports : { thing: any; }
->{    thing} : { thing: any; }
+>module.exports = {    thing} : { thing: number; }
+>module.exports : { thing: number; }
+>module : { "\"tests/cases/conformance/jsdoc/declarations/index\"": { thing: number; }; }
+>exports : { thing: number; }
+>{    thing} : { thing: number; }
 
     thing
->thing : any
+>thing : number
 
 };