WIP

Author: olafurpg

src/FileIndexer.ts

@@ -114,6 +114,23 @@ export class FileIndexer {
 
     ts.forEachChild(node, child => this.visit(child))
   }
+
+  // Given the type of `node`, assigns the types of its children. For example,
+  // when the node is a function declaration, we take the return type of the
+  // function and assign it to its body.
+  //
+  // The reason we do this is because the TypeScript compiler APIs don't seem to
+  // expose hooks to register when an object type satisfies a nominal type like
+  // in the example below:
+  //
+  // const x: NominalType = {property: 42}
+  //
+  // When asking for the type of the `{property: 42}` expression, we get the
+  // structal type `{property: number}` instead of `NominalType`. Without this
+  // manual tracking of types, "Go to definition" on `property` does not go
+  // anywhere because it's the property of a structural/anonymous type. With
+  // this manual tracking, we know that `property` goes to
+  // `NominalType.property`.
   private updatedAssignedTypeMap(node: ts.Node): void {
     if (ts.isVariableDeclaration(node) && node.type && node.initializer) {
       this.assignedType.set(node.initializer, {
@@ -209,7 +226,6 @@ export class FileIndexer {
         const returnType = this.checker.getReturnTypeOfSignature(callSignature)
         this.assignedType.set(node.body, { ...mapped, tpe: returnType })
       }
-      // TODO: handle the case when the assigned type of `() => T` and we assign thebody of the function to type `T`
     }
   }
 
@@ -488,6 +504,7 @@ export class FileIndexer {
     }
     return relationships
   }
+
   private scipSymbol(node: ts.Node): ScipSymbol {
     const fromCache: ScipSymbol | undefined =
       this.globalSymbolTable.get(node) || this.localSymbolTable.get(node)

src/TypeMapper.ts

@@ -141,20 +141,35 @@ export function getParameterTypes(
   )
 }
 
+// In some cases, `tpe.symbol.valueDeclaration` is undefined but we can recover
+// the correct value declaration by finding the parent of a property. This may
+// be caused by a bug in the tsc API where `valueDeclaration` is not correctly
+// forwarded for mapped types. Either way, this function fixes an important test
+// case in the snapshots. This approach does not work for alias types where the
+// property is not a direct child of the alias, but we guard against this case
+// by checking that the symbol of the value declaration is the same as the
+// symbol of the type.
+function correctedValueDeclaration(tpe: ts.Type): ts.Node | undefined {
+  if (tpe.symbol?.valueDeclaration) {
+    return tpe.symbol.valueDeclaration
+  }
+  for (const property of tpe.getProperties()) {
+    const parent = property?.valueDeclaration?.parent
+    if (parent !== undefined) {
+      return parent
+    }
+  }
+  return undefined
+}
+
 export function newTypeMap(
   checker: ts.TypeChecker,
   old: TypeMapper | undefined,
   tpe: ts.Type
 ): TypeMapper | undefined {
   const typeReference = asTypeReference(tpe)
   if (typeReference?.typeArguments && typeReference.typeArguments.length > 0) {
-    const [property] = tpe.getProperties()
-    if (!property) {
-      return old
-    }
-    const valueDeclaration = tpe.symbol?.valueDeclaration
-      ? tpe.symbol.valueDeclaration
-      : property?.valueDeclaration?.parent
+    const valueDeclaration = correctedValueDeclaration(tpe)
     if (valueDeclaration) {
       const valueDeclarationType = checker.getTypeAtLocation(valueDeclaration)
       if (valueDeclarationType.symbol !== tpe.symbol) {