Actually lookup type for binding property name definition

Author: weswigham

src/services/goToDefinition.ts

@@ -38,16 +38,6 @@ namespace ts.GoToDefinition {
             return [createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration)];
         }
 
-        // If the node is an identifier in bindingelement of ObjectBindingPattern (Note: ArrayBindingPattern can only declaration)
-        // instead of just return the declaration symbol which is itself. We should try to get to the original type of the ObjectBindingPattern and return the property declaration.
-        // For example:
-        //      import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
-        //
-        //      function bar<T>(onfulfilled: (value: T) => void) { //....}
-        //      interface Test {
-        //          pr/*destination*/op1: number
-        //      }
-        //      bar<Test>(({pr/*goto*/op1})=>{});
         let symbol = typeChecker.getSymbolAtLocation(node);
 
         // Could not find a symbol e.g. node is string or number keyword,
@@ -86,6 +76,26 @@ namespace ts.GoToDefinition {
                 declaration => createDefinitionInfo(declaration, shorthandSymbolKind, shorthandSymbolName, shorthandContainerName));
         }
 
+        // If the node is an identifier in bindingelement of ObjectBindingPattern (Note: ArrayBindingPattern can only declaration)
+        // instead of just return the declaration symbol which is itself. We should try to get to the original type of the ObjectBindingPattern and return the property declaration.
+        // For example:
+        //      import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo"
+        //
+        //      function bar<T>(onfulfilled: (value: T) => void) { //....}
+        //      interface Test {
+        //          pr/*destination*/op1: number
+        //      }
+        //      bar<Test>(({pr/*goto*/op1})=>{});
+        if (isPropertyName(node) && isBindingElement(node.parent) && isObjectBindingPattern(node.parent.parent) && (node.parent.propertyName ? node.parent.propertyName === node : node.parent.name === node)) {
+            const type = typeChecker.getTypeAtLocation(node.parent.parent);
+            if (type) {
+                const propSymbols = getPropertySymbolsFromType(type, node);
+                if (propSymbols) {
+                    return flatMap(propSymbols, propSymbol => getDefinitionFromSymbol(typeChecker, propSymbol, node));
+                }
+            }
+        }
+
         // If the current location we want to find its definition is in an object literal, try to get the contextual type for the
         // object literal, lookup the property symbol in the contextual type, and use this for goto-definition.
         // For example

src/services/services.ts

@@ -2138,12 +2138,17 @@ namespace ts {
     export function getPropertySymbolsFromContextualType(typeChecker: TypeChecker, node: ObjectLiteralElement): Symbol[] {
         const objectLiteral = <ObjectLiteralExpression | JsxAttributes>node.parent;
         const contextualType = typeChecker.getContextualType(objectLiteral);
-        const name = unescapeLeadingUnderscores(getTextOfPropertyName(node.name));
-        if (name && contextualType) {
+        return getPropertySymbolsFromType(contextualType, node.name);
+    }
+
+    /* @internal */
+    export function getPropertySymbolsFromType(type: Type, propName: PropertyName) {
+        const name = unescapeLeadingUnderscores(getTextOfPropertyName(propName));
+        if (name && type) {
             const result: Symbol[] = [];
-            const symbol = contextualType.getProperty(name);
-            if (contextualType.flags & TypeFlags.Union) {
-                forEach((<UnionType>contextualType).types, t => {
+            const symbol = type.getProperty(name);
+            if (type.flags & TypeFlags.Union) {
+                forEach((<UnionType>type).types, t => {
                     const symbol = t.getProperty(name);
                     if (symbol) {
                         result.push(symbol);

tests/cases/fourslash/gotoDefinitionInObjectBindingPattern1.ts

@@ -5,8 +5,8 @@
 //// }
 
 //// interface Test {
-////   pro/*destination*/p2: number
+////   /*destination*/prop2: number
 //// }
 //// bar<Test>(({pr/*goto*/op2})=>{});
 
-verify.goToDefinition("goto", "destination")
+verify.goToDefinition("goto", "destination");

tests/cases/fourslash/gotoDefinitionInObjectBindingPattern2.ts

@@ -1,8 +1,8 @@
 /// <reference path='fourslash.ts' />
 
 //// var p0 = ({a/*1*/a}) => {console.log(aa)};
-//// function f2({ a/*a1*/1, b/*b1*/1 }: { a/*a1_dest*/1: number, b/*b1_dest*/1: number } = { a1: 0, b1: 0 }) {}
+//// function f2({ a/*a1*/1, b/*b1*/1 }: { /*a1_dest*/a1: number, /*b1_dest*/b1: number } = { a1: 0, b1: 0 }) {}
 
-verify.goToDefinition("1", "1");
+verify.goToDefinition("1", []);
 verify.goToDefinition("a1", "a1_dest");
 verify.goToDefinition("b1", "b1_dest");