Implement "Find implementations" for classes, properties, and methods (#136)

olafurpg · web-flow · commit fbc91bbf79aa · 2022-05-25T21:16:59.000+02:00
* Implement "Find implementations" for classes, properties, and methods

Previously, scip-typescript did not support "Find implementations". Now,
it supports this functionality for a few commonly used patterns where
inheritance is used. This PR does not implement all locations where
inheritance is used, but we can add that functionality later.

* Address review feedback

* s/parent/ancestor/

* Update snapshots

- New test case for overloaded methods
- Avoid emitting duplicate SCIP symbol relationships
- Emit "is_reference=true" relationships for methods/properties
diff --git a/snapshots/input/syntax/src/inheritance.ts b/snapshots/input/syntax/src/inheritance.ts
@@ -1,19 +1,41 @@
+import { Overloader } from './overload'
+
 export interface Superinterface {
   property: string
   interfaceMethod(): string
 }
+export interface IntermediateSuperinterface extends Superinterface {
+  intermediateInterfaceMethod(): string
+}
 export abstract class Superclass {
   public abstract overrideMethod(): string
 }
-export abstract class IntermediateSuperclass extends Superclass {}
-export class Subclass extends IntermediateSuperclass implements Superinterface {
+export abstract class IntermediateSuperclass extends Superclass {
+  public override overrideMethod(): string {
+    return 'this will get overridden'
+  }
+  public abstract intermediateOverrideMethod(): string
+}
+export class Subclass
+  extends IntermediateSuperclass
+  implements IntermediateSuperinterface, Overloader
+{
+  public onLiteral(param: any): void {
+    throw new Error('Method not implemented.' + param)
+  }
   property = 'property'
   public overrideMethod(): string {
     throw new Error('Method not implemented.')
   }
+  public intermediateOverrideMethod(): string {
+    throw new Error('Method not implemented.')
+  }
   public interfaceMethod(): string {
     throw new Error('Method not implemented.')
   }
+  public intermediateInterfaceMethod(): string {
+    throw new Error('Method not implemented.')
+  }
 }
 export const objectLiteralImplementation: Superinterface = {
   property: 'property',
diff --git a/snapshots/input/syntax/src/overload.d.ts b/snapshots/input/syntax/src/overload.d.ts
@@ -0,0 +1,4 @@
+export interface Overloader {
+  onLiteral(param: 'a'): void
+  onLiteral(param: 'b'): void
+}
diff --git a/snapshots/input/syntax/tsconfig.json b/snapshots/input/syntax/tsconfig.json
@@ -1,5 +1,6 @@
 {
   "compilerOptions": {
+    "outDir": "dist",
     "target": "ES5"
   }
 }
diff --git a/snapshots/output/syntax/src/inheritance.ts b/snapshots/output/syntax/src/inheritance.ts
@@ -1,3 +1,6 @@
+  import { Overloader } from './overload'
+//         ^^^^^^^^^^ reference syntax 1.0.0 src/`overload.d.ts`/Overloader#
+  
   export interface Superinterface {
 //                 ^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Superinterface#
 //                 documentation ```ts\ninterface Superinterface\n```
@@ -7,6 +10,14 @@
     interfaceMethod(): string
 //  ^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Superinterface#interfaceMethod().
 //  documentation ```ts\n(method) interfaceMethod() => string\n```
+  }
+  export interface IntermediateSuperinterface extends Superinterface {
+//                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperinterface#
+//                 documentation ```ts\ninterface IntermediateSuperinterface\n```
+//                                                    ^^^^^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/Superinterface#
+    intermediateInterfaceMethod(): string
+//  ^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperinterface#intermediateInterfaceMethod().
+//  documentation ```ts\n(method) intermediateInterfaceMethod() => string\n```
   }
   export abstract class Superclass {
 //                      ^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Superclass#
@@ -15,28 +26,79 @@
 //                  ^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Superclass#overrideMethod().
 //                  documentation ```ts\n(method) overrideMethod(): string\n```
   }
-  export abstract class IntermediateSuperclass extends Superclass {}
+  export abstract class IntermediateSuperclass extends Superclass {
 //                      ^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#
 //                      documentation ```ts\nclass IntermediateSuperclass\n```
+//                      relationship implementation scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superclass#
 //                                                     ^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/Superclass#
-  export class Subclass extends IntermediateSuperclass implements Superinterface {
+    public override overrideMethod(): string {
+//                  ^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#overrideMethod().
+//                  documentation ```ts\n(method) overrideMethod(): string\n```
+//                  relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superclass#overrideMethod().
+      return 'this will get overridden'
+    }
+    public abstract intermediateOverrideMethod(): string
+//                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#intermediateOverrideMethod().
+//                  documentation ```ts\n(method) intermediateOverrideMethod(): string\n```
+  }
+  export class Subclass
 //             ^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#
 //             documentation ```ts\nclass Subclass\n```
-//                              ^^^^^^^^^^^^^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#
-//                                                                ^^^^^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/Superinterface#
+//             relationship implementation scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#
+//             relationship implementation scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperinterface#
+//             relationship implementation scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superclass#
+//             relationship implementation scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#
+//             relationship implementation scip-typescript npm syntax 1.0.0 src/`overload.d.ts`/Overloader#
+    extends IntermediateSuperclass
+//          ^^^^^^^^^^^^^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#
+    implements IntermediateSuperinterface, Overloader
+//             ^^^^^^^^^^^^^^^^^^^^^^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperinterface#
+//                                         ^^^^^^^^^^ reference syntax 1.0.0 src/`overload.d.ts`/Overloader#
+  {
+    public onLiteral(param: any): void {
+//         ^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#onLiteral().
+//         documentation ```ts\n(method) onLiteral(param: any): void\n```
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`overload.d.ts`/Overloader#onLiteral().
+//                   ^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#onLiteral().(param)
+//                   documentation ```ts\n(parameter) param: any\n```
+      throw new Error('Method not implemented.' + param)
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
+//                                                ^^^^^ reference syntax 1.0.0 src/`inheritance.ts`/Subclass#onLiteral().(param)
+    }
     property = 'property'
 //  ^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#property.
 //  documentation ```ts\n(property) property: string\n```
+//  relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#property.
     public overrideMethod(): string {
 //         ^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#overrideMethod().
 //         documentation ```ts\n(method) overrideMethod(): string\n```
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#overrideMethod().
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superclass#overrideMethod().
+      throw new Error('Method not implemented.')
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
+    }
+    public intermediateOverrideMethod(): string {
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#intermediateOverrideMethod().
+//         documentation ```ts\n(method) intermediateOverrideMethod(): string\n```
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperclass#intermediateOverrideMethod().
       throw new Error('Method not implemented.')
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
     }
     public interfaceMethod(): string {
 //         ^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#interfaceMethod().
 //         documentation ```ts\n(method) interfaceMethod(): string\n```
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#interfaceMethod().
+      throw new Error('Method not implemented.')
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
+//              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
+    }
+    public intermediateInterfaceMethod(): string {
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/Subclass#intermediateInterfaceMethod().
+//         documentation ```ts\n(method) intermediateInterfaceMethod(): string\n```
+//         relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/IntermediateSuperinterface#intermediateInterfaceMethod().
       throw new Error('Method not implemented.')
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
@@ -49,9 +111,11 @@
     property: 'property',
 //  ^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/property0:
 //  documentation ```ts\n(property) property: string\n```
+//  relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#property.
     interfaceMethod: (): string => {
 //  ^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/interfaceMethod0:
 //  documentation ```ts\n(property) interfaceMethod: () => string\n```
+//  relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#interfaceMethod().
       throw new Error('Function not implemented.')
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error#
 //              ^^^^^ reference typescript 4.6.2 lib/`lib.es5.d.ts`/Error.
@@ -71,9 +135,11 @@
       interfaceMethod: (): string => 'inferred',
 //    ^^^^^^^^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/interfaceMethod1:
 //    documentation ```ts\n(property) interfaceMethod: () => string\n```
+//    relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#interfaceMethod().
       property: 'inferred',
 //    ^^^^^^^^ definition syntax 1.0.0 src/`inheritance.ts`/property1:
 //    documentation ```ts\n(property) property: string\n```
+//    relationship implementation reference scip-typescript npm syntax 1.0.0 src/`inheritance.ts`/Superinterface#property.
     })
   }
   
diff --git a/snapshots/output/syntax/src/overload.d.ts b/snapshots/output/syntax/src/overload.d.ts
@@ -0,0 +1,15 @@
+  export interface Overloader {
+//                 ^^^^^^^^^^ definition syntax 1.0.0 src/`overload.d.ts`/Overloader#
+//                 documentation ```ts\ninterface Overloader\n```
+    onLiteral(param: 'a'): void
+//  ^^^^^^^^^ definition syntax 1.0.0 src/`overload.d.ts`/Overloader#onLiteral().
+//  documentation ```ts\n(method) onLiteral{ (param: "a"): void; (param: "b"): void; }\n```
+//            ^^^^^ definition syntax 1.0.0 src/`overload.d.ts`/Overloader#onLiteral().(param)
+//            documentation ```ts\n(parameter) param: "b"\n```
+    onLiteral(param: 'b'): void
+//  ^^^^^^^^^ definition syntax 1.0.0 src/`overload.d.ts`/Overloader#onLiteral().
+//  documentation ```ts\n(method) onLiteral{ (param: "a"): void; (param: "b"): void; }\n```
+//            ^^^^^ definition syntax 1.0.0 src/`overload.d.ts`/Overloader#onLiteral().(param)
+//            documentation ```ts\n(parameter) param: "b"\n```
+  }
+  
diff --git a/src/FileIndexer.ts b/src/FileIndexer.ts
@@ -19,6 +19,7 @@ import { Range } from './Range'
 import * as ts_inline from './TypeScriptInternal'
 
 type Descriptor = lsif.lib.codeintel.lsiftyped.Descriptor
+type Relationship = lsif.lib.codeintel.lsiftyped.Relationship
 
 export class FileIndexer {
   private localCounter = new Counter()
@@ -91,7 +92,7 @@ export class FileIndexer {
         })
       )
       if (isDefinition) {
-        this.addSymbolInformation(identifier, sym, lsifSymbol)
+        this.addSymbolInformation(identifier, sym, declaration, lsifSymbol)
         this.handleShorthandPropertyDefinition(declaration, range)
         // Only emit one symbol for definitions sites, see https://github.com/sourcegraph/lsif-typescript/issues/45
         break
@@ -139,6 +140,7 @@ export class FileIndexer {
   private addSymbolInformation(
     node: ts.Node,
     sym: ts.Symbol,
+    declaration: ts.Node,
     symbol: LsifSymbol
   ): void {
     const documentation = [
@@ -148,11 +150,68 @@ export class FileIndexer {
     if (docstring.length > 0) {
       documentation.push(ts.displayPartsToString(docstring))
     }
+
     this.document.symbols.push(
-      new lsiftyped.SymbolInformation({ symbol: symbol.value, documentation })
+      new lsiftyped.SymbolInformation({
+        symbol: symbol.value,
+        documentation,
+        relationships: this.relationships(declaration, symbol),
+      })
     )
   }
 
+  private relationships(
+    declaration: ts.Node,
+    declarationSymbol: LsifSymbol
+  ): Relationship[] {
+    const relationships: Relationship[] = []
+    const isAddedSymbol = new Set<string>()
+    const pushImplementation = (
+      node: ts.NamedDeclaration,
+      isReferences: boolean
+    ): void => {
+      const symbol = this.lsifSymbol(node)
+      if (symbol.isEmpty()) {
+        return
+      }
+      if (symbol.value === declarationSymbol.value) {
+        return
+      }
+      if (isAddedSymbol.has(symbol.value)) {
+        // Avoid duplicate relationships. This can happen for overloaded methods
+        // that have different ts.Symbol but the same SCIP symbol.
+        return
+      }
+      isAddedSymbol.add(symbol.value)
+      relationships.push(
+        new lsiftyped.Relationship({
+          symbol: symbol.value,
+          is_implementation: true,
+          is_reference: isReferences,
+        })
+      )
+    }
+    if (ts.isClassDeclaration(declaration)) {
+      this.forEachAncestor(declaration, ancestor => {
+        pushImplementation(ancestor, false)
+      })
+    } else if (
+      ts.isMethodDeclaration(declaration) ||
+      ts.isMethodSignature(declaration) ||
+      ts.isPropertyAssignment(declaration) ||
+      ts.isPropertyDeclaration(declaration)
+    ) {
+      const declarationName = declaration.name.getText()
+      this.forEachAncestor(declaration.parent, ancestor => {
+        for (const member of ancestor.members) {
+          if (declarationName === member.name?.getText()) {
+            pushImplementation(member, true)
+          }
+        }
+      })
+    }
+    return relationships
+  }
   private declarationName(node: ts.Node): ts.Node | undefined {
     if (
       ts.isEnumDeclaration(node) ||
@@ -397,6 +456,84 @@ export class FileIndexer {
     }
     return node.getText() + ': ' + type()
   }
+
+  // Invokes the `onAncestor` callback for all "ancestors" of the provided node,
+  // where "ancestor" is loosely defined as the superclass or superinterface of
+  // that node. The callback is invoked on the `node` parameter itself if it's
+  // class-like or an interface.
+  private forEachAncestor(
+    node: ts.Node,
+    onAncestor: (
+      ancestor: ts.ClassLikeDeclaration | ts.InterfaceDeclaration
+    ) => void
+  ): void {
+    const isVisited = new Set<ts.Node>()
+    const loop = (declaration: ts.Node): void => {
+      if (isVisited.has(declaration)) {
+        return
+      }
+      isVisited.add(declaration)
+      if (
+        ts.isClassLike(declaration) ||
+        ts.isInterfaceDeclaration(declaration)
+      ) {
+        onAncestor(declaration)
+      }
+      if (ts.isObjectLiteralExpression(declaration)) {
+        const tpe = this.inferredTypeOfObjectLiteral(declaration)
+        for (const symbolDeclaration of tpe.symbol?.declarations || []) {
+          loop(symbolDeclaration)
+        }
+      } else if (
+        ts.isClassLike(declaration) ||
+        ts.isInterfaceDeclaration(declaration)
+      ) {
+        for (const heritageClause of declaration?.heritageClauses || []) {
+          for (const tpe of heritageClause.types) {
+            const ancestorSymbol = this.getTSSymbolAtLocation(tpe.expression)
+            if (ancestorSymbol) {
+              for (const ancestorDecl of ancestorSymbol.declarations || []) {
+                loop(ancestorDecl)
+              }
+            }
+          }
+        }
+      }
+    }
+    loop(node)
+  }
+
+  // Returns the "inferred" type of the provided object literal, where
+  // "inferred" is loosely defined as the type that is expected in the position
+  // where the object literal appears.  For example, the object literal in
+  // `const x: SomeInterface = {y: 42}` has the inferred type `SomeInterface`
+  // even if `this.checker.getTypeAtLocation({y: 42})` does not return
+  // `SomeInterface`. The object literal could satisfy many types, but in this
+  // particular location must only satisfy `SomeInterface`.
+  private inferredTypeOfObjectLiteral(
+    node: ts.ObjectLiteralExpression
+  ): ts.Type {
+    if (ts.isVariableDeclaration(node.parent)) {
+      // Example, return `SomeInterface` from `const x: SomeInterface = {y: 42}`.
+      return this.checker.getTypeAtLocation(node.parent.name)
+    }
+
+    if (ts.isCallOrNewExpression(node.parent)) {
+      // Example: return the type of the second parameter of `someMethod` from
+      // the expression `someMethod(someParameter, {y: 42})`.
+      const signature = this.checker.getResolvedSignature(node.parent)
+      for (const [index, argument] of (node.parent.arguments || []).entries()) {
+        if (argument === node) {
+          const parameterSymbol = signature?.getParameters()[index]
+          if (parameterSymbol) {
+            return this.checker.getTypeOfSymbolAtLocation(parameterSymbol, node)
+          }
+        }
+      }
+    }
+
+    return this.checker.getTypeAtLocation(node)
+  }
 }
 
 function isAnonymousContainerOfSymbols(node: ts.Node): boolean {
diff --git a/src/SnapshotTesting.ts b/src/SnapshotTesting.ts
@@ -63,7 +63,7 @@ export function formatSnapshot(
       info.relationships.sort((a, b) => a.symbol.localeCompare(b.symbol))
       for (const relationship of info.relationships) {
         out.push(prefix)
-        out.push('relationship ')
+        out.push('relationship')
         if (relationship.is_implementation) {
           out.push(' implementation')
         }
@@ -73,6 +73,7 @@ export function formatSnapshot(
         if (relationship.is_type_definition) {
           out.push(' type_definition')
         }
+        out.push(' ' + relationship.symbol)
       }
       out.push('\n')
     }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"compilerOptions": {`
	`3`	`+ "outDir": "dist",`
`3`	`4`	`"target": "ES5"`
`4`	`5`	`}`
`5`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ export function formatSnapshot(`
`63`	`63`	`info.relationships.sort((a, b) => a.symbol.localeCompare(b.symbol))`
`64`	`64`	`for (const relationship of info.relationships) {`
`65`	`65`	`out.push(prefix)`
`66`		`- out.push('relationship ')`
	`66`	`+ out.push('relationship')`
`67`	`67`	`if (relationship.is_implementation) {`
`68`	`68`	`out.push(' implementation')`
`69`	`69`	`}`
`@@ -73,6 +73,7 @@ export function formatSnapshot(`
`73`	`73`	`if (relationship.is_type_definition) {`
`74`	`74`	`out.push(' type_definition')`
`75`	`75`	`}`
	`76`	`+ out.push(' ' + relationship.symbol)`
`76`	`77`	`}`
`77`	`78`	`out.push('\n')`
`78`	`79`	`}`