[Not Ready] [typespec-vscode] Improvements for the intellisense of tspconfig.yaml

.chronus/changes/improvements-for-the-intellisense-of-tspconfig.yaml-2024-11-19-2-35-2.md

@@ -0,0 +1,13 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Improvements for the intellisense of tspconfig.yaml
+- Supports auto-completion of the extends and imports paths
+- The rule or ruleSets of the linter can be auto-completed
+- Emitter optoins autocomplete intelligently handles quotation mark display
+- Autocomplete of variable interpolation
+- The parameters of emitter's options distinguish whether they are required or optional

packages/compiler/src/server/emitter-provider.ts → packages/compiler/src/server/lib-provider.ts

@@ -1,54 +1,57 @@
 import { joinPaths } from "../core/path-utils.js";
 import { NpmPackage, NpmPackageProvider } from "./npm-package-provider.js";
 
-export class EmitterProvider {
-  private isEmitterPackageCache = new Map<string, boolean>();
-  constructor(private npmPackageProvider: NpmPackageProvider) {}
+export class LibraryProvider {
+  private libPackageFilterResultCache = new Map<string, boolean>();
+  constructor(
+    private npmPackageProvider: NpmPackageProvider,
+    private filter: (libExports: Record<string, any>) => boolean,
+  ) {}
 
   /**
    *
-   * @param startFolder folder starts to search for package.json with emitters defined as dependencies
+   * @param startFolder folder starts to search for package.json with library defined as dependencies
    * @returns
    */
-  async listEmitters(startFolder: string): Promise<Record<string, NpmPackage>> {
+  async listLibraries(startFolder: string): Promise<Record<string, NpmPackage>> {
     const packageJsonFolder = await this.npmPackageProvider.getPackageJsonFolder(startFolder);
     if (!packageJsonFolder) return {};
 
     const pkg = await this.npmPackageProvider.get(packageJsonFolder);
     const data = await pkg?.getPackageJsonData();
     if (!data) return {};
 
-    const emitters: Record<string, NpmPackage> = {};
+    const libs: Record<string, NpmPackage> = {};
     const allDep = {
       ...(data.dependencies ?? {}),
       ...(data.devDependencies ?? {}),
     };
     for (const dep of Object.keys(allDep)) {
-      const depPkg = await this.getEmitterFromDep(packageJsonFolder, dep);
+      const depPkg = await this.getLibraryFromDep(packageJsonFolder, dep);
       if (depPkg) {
-        emitters[dep] = depPkg;
+        libs[dep] = depPkg;
       }
     }
-    return emitters;
+    return libs;
   }
 
   /**
    *
-   * @param startFolder folder starts to search for package.json with emitters defined as dependencies
-   * @param emitterName
+   * @param startFolder folder starts to search for package.json with library defined as dependencies
+   * @param libName
    * @returns
    */
-  async getEmitter(startFolder: string, emitterName: string): Promise<NpmPackage | undefined> {
+  async getLibrary(startFolder: string, libName: string): Promise<NpmPackage | undefined> {
     const packageJsonFolder = await this.npmPackageProvider.getPackageJsonFolder(startFolder);
     if (!packageJsonFolder) {
       return undefined;
     }
-    return this.getEmitterFromDep(packageJsonFolder, emitterName);
+    return this.getLibraryFromDep(packageJsonFolder, libName);
   }
 
-  private async isEmitter(depName: string, pkg: NpmPackage) {
-    if (this.isEmitterPackageCache.has(depName)) {
-      return this.isEmitterPackageCache.get(depName);
+  private async getLibFilterResult(depName: string, pkg: NpmPackage) {
+    if (this.libPackageFilterResultCache.has(depName)) {
+      return this.libPackageFilterResultCache.get(depName);
     }
 
     const data = await pkg.getPackageJsonData();
@@ -61,19 +64,20 @@ export class EmitterProvider {
       const exports = await pkg.getModuleExports();
       // don't add to cache when failing to load exports which is unexpected
       if (!exports) return false;
-      const isEmitter = exports.$onEmit !== undefined;
-      this.isEmitterPackageCache.set(depName, isEmitter);
-      return isEmitter;
+
+      const filterResult = this.filter(exports);
+      this.libPackageFilterResultCache.set(depName, filterResult);
+      return filterResult;
     } else {
-      this.isEmitterPackageCache.set(depName, false);
+      this.libPackageFilterResultCache.set(depName, false);
       return false;
     }
   }
 
-  private async getEmitterFromDep(packageJsonFolder: string, depName: string) {
+  private async getLibraryFromDep(packageJsonFolder: string, depName: string) {
     const depFolder = joinPaths(packageJsonFolder, "node_modules", depName);
     const depPkg = await this.npmPackageProvider.get(depFolder);
-    if (depPkg && (await this.isEmitter(depName, depPkg))) {
+    if (depPkg && (await this.getLibFilterResult(depName, depPkg))) {
       return depPkg;
     }
     return undefined;

packages/compiler/src/server/serverlib.ts

@@ -80,9 +80,9 @@ import { createCompileService } from "./compile-service.js";
 import { resolveCompletion } from "./completion.js";
 import { Commands } from "./constants.js";
 import { convertDiagnosticToLsp } from "./diagnostics.js";
-import { EmitterProvider } from "./emitter-provider.js";
 import { createFileService } from "./file-service.js";
 import { createFileSystemCache } from "./file-system-cache.js";
+import { LibraryProvider } from "./lib-provider.js";
 import { NpmPackageProvider } from "./npm-package-provider.js";
 import { getSymbolStructure } from "./symbol-structure.js";
 import { provideTspconfigCompletionItems } from "./tspconfig/completion.js";
@@ -114,7 +114,14 @@ export function createServer(host: ServerHost): Server {
   });
   const compilerHost = createCompilerHost();
   const npmPackageProvider = new NpmPackageProvider(compilerHost);
-  const emitterProvider = new EmitterProvider(npmPackageProvider);
+  const emitterProvider = new LibraryProvider(
+    npmPackageProvider,
+    (exports) => exports.$onEmit !== undefined,
+  );
+  const linterProvider = new LibraryProvider(
+    npmPackageProvider,
+    (exports) => exports.$linter !== undefined,
+  );
 
   const compileService = createCompileService({
     fileService,
@@ -703,7 +710,9 @@ export function createServer(host: ServerHost): Server {
       if (doc) {
         const items = await provideTspconfigCompletionItems(doc, params.position, {
           fileService,
+          compilerHost,
           emitterProvider,
+          linterProvider,
           log,
         });
         return CompletionList.create(items);