Symbols missing from nodes when SourceFile requested via LanguageService, but not via Program

[nkohari]

I got tripped up when using the compiler API, and I wanted to see if it was just me being confused or an actual bug. :) It seems like SourceFiles that are returned from LanguageService.getSourceFile() don't include symbols, whereas those loaded via Program.getSourceFile() do.

If I request a file via:

languageService.getSourceFile("example.ts");

...it will be returned without symbols, so if I try calling any of TypeChecker's methods on it, it will either throw errors or returned undefined. If instead I request files via:

languageService.getProgram().getSourceFile("example.ts");

..the returned file has the symbols and works fine with TypeChecker.

I understand that mixing these two APIs is probably not a normal use case. I'm working on a tool that alters the source of a program as it's being compiled, so having access to LanguageService is really helpful, but I also need the TypeChecker.

(Also, if this is just a problem with my implementation of LanguageServiceHost, please let me know!)

TypeScript Version: Behavior appears on 1.8.7, 1.8.9, and 1.9.0-dev.20160318

Test Case

test.ts

import * as ts from 'typescript';
import * as fs from 'fs';

interface ScriptInfo {
  text: string
  version: number
}

export class LanguageServiceHost implements ts.LanguageServiceHost {

  files: { [name: string]: ScriptInfo } = {};

  constructor(protected rootFileNames: string[], protected options: ts.CompilerOptions) {
    for (const fileName of rootFileNames) {
      this.getScriptInfo(fileName);
    }
  }

  getCompilationSettings() {
    return this.options;
  }

  getScriptFileNames() {
    return this.rootFileNames;
  }

  getScriptVersion(fileName: string) {
    let info = this.getScriptInfo(fileName);
    return info.version.toString();
  }

  getScriptSnapshot(fileName: string) {
    let info = this.getScriptInfo(fileName);
    return ts.ScriptSnapshot.fromString(info.text);
  }

  getCurrentDirectory() {
    return process.cwd();
  }

  getDefaultLibFileName(options: ts.CompilerOptions) {
    return ts.getDefaultLibFilePath(options);
  }

  getScriptInfo(fileName: string): ScriptInfo {
    let info = this.files[fileName];
    if (!info) {
      this.files[fileName] = info = {
        text: fs.readFileSync(fileName).toString(),
        version: 1
      };
    }
    return info;
  }

}

const languageServiceHost = new LanguageServiceHost(['case.ts'], {
  target: ts.ScriptTarget.ES5,
  module: ts.ModuleKind.CommonJS
});

const languageService = ts.createLanguageService(languageServiceHost, ts.createDocumentRegistry());
const program = languageService.getProgram();
const checker = program.getTypeChecker();

function listClassMethods(file: ts.SourceFile) {
  let visit = (node: ts.Node) => {
    if (node.kind == ts.SyntaxKind.ClassDeclaration) {
      const decl = <ts.ClassDeclaration> node;
      for (const member of decl.members) {
        if (member.kind == ts.SyntaxKind.MethodDeclaration) {
          const method = <ts.MethodDeclaration> member;
          const symbol = checker.getSymbolAtLocation(method.name);
          if (symbol) {
            console.log(symbol.getName());
          }
          else {
            console.log("Couldn't resolve symbol")
          }
        }
      }
    }
    ts.forEachChild(node, visit);
  }
  ts.forEachChild(file, visit);
}

listClassMethods(languageService.getSourceFile('case.ts'));
listClassMethods(program.getSourceFile('case.ts'));

case.ts

interface IExample {
  getName: () => string
}

class A implements IExample {
  getName() {
    return 'A';
  }
}

class B implements IExample {
  getName() {
    return 'B';
  }
}

Expected behavior:

$ node test.js
getName
getName
getName
getName

Actual behavior:

$ node test.js
Couldn't resolve symbol
Couldn't resolve symbol
getName
getName

Thanks for your help, and for the great work on TypeScript and the compiler API!

[vladima]

I don't see any reasons why LanguageService.getSourceFile is exposed - it should be internal method. The reason why behavior is different: LanguageService.getSourceFile returns a SourceFile that was not bound and it is only usable for syntactic analysis.