feat(language-service): provide external files to tsserver.

Official angular language service removed GetExternalFiles() method that is necessary to support external templates from typescript plugin. This commit reverts f05e171. So I can use angular language service without duplicated tsserver instance.

Author: andrius-pra

packages/language-service/src/ts_plugin.ts

@@ -11,8 +11,50 @@ import * as tss from 'typescript/lib/tsserverlibrary';
 import {createLanguageService} from './language_service';
 import {TypeScriptServiceHost} from './typescript_host';
 
+/**
+ * A note about importing TypeScript module.
+ * The TypeScript module is supplied by tsserver at runtime to ensure version
+ * compatibility. In Angular language service, the rollup output is augmented
+ * with a "banner" shim that overwrites 'typescript' and
+ * 'typescript/lib/tsserverlibrary' imports with the value supplied by tsserver.
+ * This means import of either modules will not be "required", but they'll work
+ * just like regular imports.
+ */
+
+const projectHostMap = new WeakMap<tss.server.Project, TypeScriptServiceHost>();
+
+/**
+ * Return the external templates discovered through processing all NgModules in
+ * the specified `project`.
+ * This function is called in a few situations:
+ * 1. When a ConfiguredProject is created
+ *    https://github.com/microsoft/TypeScript/blob/c26c44d5fceb04ea14da20b6ed23449df777ff34/src/server/editorServices.ts#L1755
+ * 2. When updateGraph() is called on a Project
+ *    https://github.com/microsoft/TypeScript/blob/c26c44d5fceb04ea14da20b6ed23449df777ff34/src/server/project.ts#L915
+ * @param project Most likely a ConfiguredProject
+ */
+export function getExternalFiles(project: tss.server.Project): string[] {
+  if (!project.hasRoots()) {
+    // During project initialization where there is no root files yet we should
+    // not do any work.
+    return [];
+  }
+  const ngLSHost = projectHostMap.get(project);
+  if (!ngLSHost) {
+    // Without an Angular host there is no way to get template references.
+    return [];
+  }
+  const templates = ngLSHost.getTemplateReferences();
+  const logger = project.projectService.logger;
+  if (logger.hasLevel(tss.server.LogLevel.verbose)) {
+    // Log external files to help debugging.
+    logger.info(`External files in ${project.projectName}: ${JSON.stringify(templates)}`);
+  }
+  return templates;
+}
+
 export function create(info: tss.server.PluginCreateInfo): tss.LanguageService {
-  const {languageService: tsLS, languageServiceHost: tsLSHost, config} = info;
+  const {project, languageService: tsLS, languageServiceHost: tsLSHost, config} = info;
   // This plugin could operate under two different modes:
   // 1. TS + Angular
   //    Plugin augments TS language service to provide additional Angular
@@ -25,6 +67,7 @@ export function create(info: tss.server.PluginCreateInfo): tss.LanguageService {
   const angularOnly = config ? config.angularOnly === true : false;
   const ngLSHost = new TypeScriptServiceHost(tsLSHost, tsLS);
   const ngLS = createLanguageService(ngLSHost);
+  projectHostMap.set(project, ngLSHost);
 
   function getCompletionsAtPosition(
       fileName: string, position: number, options: tss.GetCompletionsAtPositionOptions|undefined) {

packages/language-service/src/types.ts

@@ -154,6 +154,11 @@ export interface LanguageServiceHost {
    */
   getAnalyzedModules(): NgAnalyzedModules;
 
+  /**
+   * Return a list all the template files referenced by the project.
+   */
+  getTemplateReferences(): string[];
+
   /**
    * Return the AST for both HTML and template for the contextFile.
    */

packages/language-service/src/typescript_host.ts

@@ -8,6 +8,7 @@
 
 import {analyzeNgModules, AotSummaryResolver, CompileDirectiveSummary, CompileMetadataResolver, CompileNgModuleMetadata, CompilePipeSummary, CompilerConfig, createOfflineCompileUrlResolver, DirectiveNormalizer, DirectiveResolver, DomElementSchemaRegistry, FormattedError, FormattedMessageChain, HtmlParser, isFormattedError, JitSummaryResolver, Lexer, NgAnalyzedModules, NgModuleResolver, Parser, ParseTreeResult, PipeResolver, ResourceLoader, StaticReflector, StaticSymbol, StaticSymbolCache, StaticSymbolResolver, TemplateParser} from '@angular/compiler';
 import {SchemaMetadata, ViewEncapsulation, ɵConsole as Console} from '@angular/core';
+import * as ts from 'typescript';
 import * as tss from 'typescript/lib/tsserverlibrary';
 
 import {createLanguageService} from './language_service';
@@ -66,6 +67,7 @@ export class TypeScriptServiceHost implements LanguageServiceHost {
   private readonly fileVersions = new Map<string, string>();
 
   private lastProgram: tss.Program|undefined = undefined;
+  private templateReferences: string[] = [];
   private analyzedModules: NgAnalyzedModules = {
     files: [],
     ngModuleByPipeOrDirective: new Map(),
@@ -151,6 +153,11 @@ export class TypeScriptServiceHost implements LanguageServiceHost {
     return this.resolver.getReflector() as StaticReflector;
   }
 
+  getTemplateReferences(): string[] {
+    this.getAnalyzedModules();
+    return [...this.templateReferences];
+  }
+
   /**
    * Checks whether the program has changed and returns all analyzed modules.
    * If program has changed, invalidate all caches and update fileToComponent
@@ -164,6 +171,7 @@ export class TypeScriptServiceHost implements LanguageServiceHost {
     }
 
     // Invalidate caches
+    this.templateReferences = [];
     this.fileToComponent.clear();
     this.collectedErrors.clear();
     this.resolver.clearCache();
@@ -194,6 +202,11 @@ export class TypeScriptServiceHost implements LanguageServiceHost {
               this.reflector.componentModuleUrl(directive.reference),
               metadata.template.templateUrl);
           this.fileToComponent.set(templateName, directive.reference);
+          if (this.tsLsHost.fileExists && this.tsLsHost.fileExists(templateName)) {
+            this.templateReferences.push(templateName);
+          } else if (!!this.tsLsHost.getScriptSnapshot(templateName)) {
+            this.templateReferences.push(templateName);
+          }
         }
       }
     }

packages/language-service/test/BUILD.bazel

@@ -48,6 +48,7 @@ ts_library(
         "html_info_spec.ts",
         "language_service_spec.ts",
         "reflector_host_spec.ts",
+        "template_references_spec.ts",
         "ts_plugin_spec.ts",
         "typescript_host_spec.ts",
         "utils_spec.ts",

packages/language-service/test/template_references_spec.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+import * as ts from 'typescript';
+
+import {TypeScriptServiceHost} from '../src/typescript_host';
+
+import {MockTypescriptHost} from './test_utils';
+
+describe('references', () => {
+  const mockHost = new MockTypescriptHost(['/app/main.ts']);
+  const service = ts.createLanguageService(mockHost);
+  const ngHost = new TypeScriptServiceHost(mockHost, service);
+
+  beforeEach(() => { mockHost.reset(); });
+
+  it('should be able to determine that test.ng is a template reference', () => {
+    const templates = ngHost.getTemplateReferences();
+    expect(templates).toEqual(['/app/test.ng']);
+  });
+
+  it('should be able to get template references for an invalid project', () => {
+    const moduleCode = `
+      import {NgModule} from '@angular/core';
+      import {NewClass} from './test.component';
+
+      @NgModule({declarations: [NewClass]}) export class TestModule {}`;
+    const classCode = `
+      export class NewClass {}
+
+      @Component({})
+      export class SomeComponent {}
+    `;
+    mockHost.addScript('/app/test.module.ts', moduleCode);
+    mockHost.addScript('/app/test.component.ts', classCode);
+    const templates = ngHost.getTemplateReferences();
+    expect(templates).toEqual(['/app/test.ng']);
+  });
+
+});

packages/language-service/test/ts_plugin_spec.ts

@@ -8,7 +8,7 @@
 
 import * as ts from 'typescript';
 
-import {create} from '../src/ts_plugin';
+import {create, getExternalFiles} from '../src/ts_plugin';
 import {CompletionKind} from '../src/types';
 
 import {MockTypescriptHost} from './test_utils';
@@ -67,6 +67,11 @@ describe('plugin', () => {
     }
   });
 
+  it('should return external templates as external files', () => {
+    const externalFiles = getExternalFiles(mockProject);
+    expect(externalFiles).toEqual(['/app/test.ng']);
+  });
+
   it('should not report template errors on tour of heroes', () => {
     const filesWithTemplates = [
       // Ignore all '*-cases.ts' files as they intentionally contain errors.