Report diagnostics for unused "using" so that they will be shown properly in ide

.chronus/changes/unused-using-2024-11-26-19-12-40.md

@@ -0,0 +1,7 @@
+---
+changeKind: feature
+packages:
+  - "@typespec/compiler"
+---
+
+Support diagnostics for unused using statement

packages/compiler/src/core/compiler-code-fixes/remove-unused-code.codefix.ts

@@ -0,0 +1,16 @@
+import { defineCodeFix, getSourceLocation } from "../diagnostics.js";
+import { type ImportStatementNode, type UsingStatementNode } from "../types.js";
+
+/**
+ * Quick fix that remove unused code.
+ */
+export function removeUnusedCodeCodeFix(node: ImportStatementNode | UsingStatementNode) {
+  return defineCodeFix({
+    id: "remove-unused-code",
+    label: `Remove unused code`,
+    fix: (context) => {
+      const location = getSourceLocation(node);
+      return context.replaceText(location, "");
+    },
+  });
+}

packages/compiler/src/core/linter.ts

@@ -1,25 +1,33 @@
+import { removeUnusedCodeCodeFix } from "./compiler-code-fixes/remove-unused-code.codefix.js";
 import { DiagnosticCollector, compilerAssert, createDiagnosticCollector } from "./diagnostics.js";
 import { getLocationContext } from "./helpers/location-context.js";
+import { createLinterRule, defineLinter, paramMessage } from "./library.js";
 import { createDiagnostic } from "./messages.js";
+import { NameResolver } from "./name-resolver.js";
 import type { Program } from "./program.js";
 import { EventEmitter, mapEventEmitterToNodeListener, navigateProgram } from "./semantic-walker.js";
 import {
   Diagnostic,
   DiagnosticMessages,
-  LibraryInstance,
+  IdentifierNode,
   LinterDefinition,
   LinterResolvedDefinition,
   LinterRule,
   LinterRuleContext,
   LinterRuleDiagnosticReport,
   LinterRuleSet,
+  MemberExpressionNode,
   NoTarget,
   RuleRef,
   SemanticNodeListener,
+  SyntaxKind,
 } from "./types.js";
 
+type LinterLibraryInstance = { linter: LinterResolvedDefinition };
+
 export interface Linter {
   extendRuleSet(ruleSet: LinterRuleSet): Promise<readonly Diagnostic[]>;
+  registerLinterLibrary(name: string, lib?: LinterLibraryInstance): void;
   lint(): readonly Diagnostic[];
 }
 
@@ -53,16 +61,17 @@ export function resolveLinterDefinition(
 
 export function createLinter(
   program: Program,
-  loadLibrary: (name: string) => Promise<LibraryInstance | undefined>,
+  loadLibrary: (name: string) => Promise<LinterLibraryInstance | undefined>,
 ): Linter {
   const tracer = program.tracer.sub("linter");
 
   const ruleMap = new Map<string, LinterRule<string, any>>();
   const enabledRules = new Map<string, LinterRule<string, any>>();
-  const linterLibraries = new Map<string, LibraryInstance | undefined>();
+  const linterLibraries = new Map<string, LinterLibraryInstance | undefined>();
 
   return {
     extendRuleSet,
+    registerLinterLibrary,
     lint,
   };
 
@@ -158,18 +167,21 @@ export function createLinter(
     return diagnostics.diagnostics;
   }
 
-  async function resolveLibrary(name: string): Promise<LibraryInstance | undefined> {
+  async function resolveLibrary(name: string): Promise<LinterLibraryInstance | undefined> {
     const loadedLibrary = linterLibraries.get(name);
     if (loadedLibrary === undefined) {
       return registerLinterLibrary(name);
     }
     return loadedLibrary;
   }
 
-  async function registerLinterLibrary(name: string): Promise<LibraryInstance | undefined> {
+  async function registerLinterLibrary(
+    name: string,
+    lib?: LinterLibraryInstance,
+  ): Promise<LinterLibraryInstance | undefined> {
     tracer.trace("register-library", name);
 
-    const library = await loadLibrary(name);
+    const library = lib ?? (await loadLibrary(name));
     const linter = library?.linter;
     if (linter?.rules) {
       for (const rule of linter.rules) {
@@ -253,3 +265,53 @@ export function createLinterRuleContext<N extends string, DM extends DiagnosticM
     }
   }
 }
+
+export const builtInLinterLibraryName = `@typespec/compiler`;
+export const builtInLinterRule_UnusedUsing = `unused-using`;
+export function createBuiltInLinterLibrary(nameResolver: NameResolver): LinterLibraryInstance {
+  const builtInLinter: LinterResolvedDefinition = resolveLinterDefinition(
+    builtInLinterLibraryName,
+    createBuiltInLinter(nameResolver),
+  );
+  return { linter: builtInLinter };
+}
+function createBuiltInLinter(nameResolver: NameResolver): LinterDefinition {
+  const unusedUsingLinterRule = createUnusedUsingLinterRule();
+
+  return defineLinter({
+    rules: [unusedUsingLinterRule],
+  });
+
+  function createUnusedUsingLinterRule() {
+    return createLinterRule({
+      name: builtInLinterRule_UnusedUsing,
+      severity: "warning",
+      description: "Linter rules for unused using statement.",
+      messages: {
+        default: paramMessage`'using ${"code"}' is declared but never be used.`,
+      },
+      create(context) {
+        return {
+          root: (_root) => {
+            const getUsingName = (node: MemberExpressionNode | IdentifierNode): string => {
+              if (node.kind === SyntaxKind.MemberExpression) {
+                return `${getUsingName(node.base)}${node.selector}${node.id.sv}`;
+              } else {
+                // identifier node
+                return node.sv;
+              }
+            };
+            nameResolver.getUnusedUsings().forEach((target) => {
+              context.reportDiagnostic({
+                messageId: "default",
+                format: { code: getUsingName(target.name) },
+                target,
+                codefixes: [removeUnusedCodeCodeFix(target)],
+              });
+            });
+          },
+        };
+      },
+    });
+  }
+}

packages/compiler/src/core/name-resolver.ts

@@ -61,7 +61,7 @@
 import { Mutable, mutate } from "../utils/misc.js";
 import { createSymbol, createSymbolTable, getSymNode } from "./binder.js";
 import { compilerAssert } from "./diagnostics.js";
-import { visitChildren } from "./parser.js";
+import { getFirstAncestor, visitChildren } from "./parser.js";
 import { Program } from "./program.js";
 import {
   AliasStatementNode,
@@ -95,6 +95,7 @@ import {
   TypeReferenceNode,
   TypeSpecScriptNode,
   UnionStatementNode,
+  UsingStatementNode,
 } from "./types.js";
 
 export interface NameResolver {
@@ -143,6 +144,9 @@ export interface NameResolver {
     node: TypeReferenceNode | IdentifierNode | MemberExpressionNode,
   ): ResolutionResult;
 
+  /** Get the using statement nodes which is not used in resolving yet */
+  getUnusedUsings(): UsingStatementNode[];
+
   /** Built-in symbols. */
   readonly symbols: {
     /** Symbol for the global namespace */
@@ -176,6 +180,11 @@ export function createResolver(program: Program): NameResolver {
   mutate(globalNamespaceNode).symbol = globalNamespaceSym;
   mutate(globalNamespaceSym.exports).set(globalNamespaceNode.id.sv, globalNamespaceSym);
 
+  /**
+   * Tracking the symbols that are used through using.
+   */
+  const usedUsingSym = new Map<TypeSpecScriptNode, Set<Sym>>();
+
   const metaTypePrototypes = createMetaTypePrototypes();
 
   const nullSym = createSymbol(undefined, "null", SymbolFlags.None);
@@ -223,8 +232,33 @@ export function createResolver(program: Program): NameResolver {
     resolveTypeReference,
 
     getAugmentDecoratorsForSym,
+    getUnusedUsings,
   };
 
+  function getUnusedUsings(): UsingStatementNode[] {
+    const unusedUsings: Set<UsingStatementNode> = new Set();
+    for (const file of program.sourceFiles.values()) {
+      const lc = program.getSourceFileLocationContext(file.file);
+      if (lc.type === "project") {
+        const usedSym = usedUsingSym.get(file) ?? new Set<Sym>();
+        for (const using of file.usings) {
+          const table = getNodeLinks(using.name).resolvedSymbol;
+          let used = false;
+          for (const [_, sym] of table?.exports ?? new Map<string, Sym>()) {
+            if (usedSym.has(getMergedSymbol(sym))) {
+              used = true;
+              break;
+            }
+          }
+          if (used === false) {
+            unusedUsings.add(using);
+          }
+        }
+      }
+    }
+    return [...unusedUsings];
+  }
+
   function getAugmentDecoratorsForSym(sym: Sym) {
     return augmentDecoratorsForSym.get(sym) ?? [];
   }
@@ -961,6 +995,15 @@ export function createResolver(program: Program): NameResolver {
       if ("locals" in scope && scope.locals !== undefined) {
         binding = tableLookup(scope.locals, node, options.resolveDecorators);
         if (binding) {
+          if (binding.flags & SymbolFlags.Using && binding.symbolSource) {
+            const fileNode = getFirstAncestor(node, (n) => n.kind === SyntaxKind.TypeSpecScript) as
+              | TypeSpecScriptNode
+              | undefined;
+            if (fileNode) {
+              usedUsingSym.get(fileNode)?.add(binding.symbolSource) ??
+                usedUsingSym.set(fileNode, new Set([binding.symbolSource]));
+            }
+          }
           return resolvedResult(binding);
         }
       }
@@ -998,6 +1041,10 @@ export function createResolver(program: Program): NameResolver {
               []),
           ]);
         }
+        if (usingBinding.flags & SymbolFlags.Using && usingBinding.symbolSource) {
+          usedUsingSym.get(scope)?.add(usingBinding.symbolSource) ??
+            usedUsingSym.set(scope, new Set([usingBinding.symbolSource]));
+        }
         return resolvedResult(usingBinding.symbolSource!);
       }
     }

packages/compiler/src/core/program.ts

@@ -20,7 +20,12 @@ import { compilerAssert } from "./diagnostics.js";
 import { resolveTypeSpecEntrypoint } from "./entrypoint-resolution.js";
 import { ExternalError } from "./external-error.js";
 import { getLibraryUrlsLoaded } from "./library.js";
-import { createLinter, resolveLinterDefinition } from "./linter.js";
+import {
+  builtInLinterLibraryName,
+  createBuiltInLinterLibrary,
+  createLinter,
+  resolveLinterDefinition,
+} from "./linter.js";
 import { createLogger } from "./logger/index.js";
 import { createTracer } from "./logger/tracer.js";
 import { createDiagnostic } from "./messages.js";
@@ -230,13 +235,15 @@ export async function compile(
   oldProgram = undefined;
   setCurrentProgram(program);
 
+  const resolver = createResolver(program);
+  resolver.resolveProgram();
+
   const linter = createLinter(program, (name) => loadLibrary(basedir, name));
+  linter.registerLinterLibrary(builtInLinterLibraryName, createBuiltInLinterLibrary(resolver));
   if (options.linterRuleSet) {
     program.reportDiagnostics(await linter.extendRuleSet(options.linterRuleSet));
   }
 
-  const resolver = createResolver(program);
-  resolver.resolveProgram();
   program.checker = createChecker(program, resolver);
   program.checker.checkProgram();
 

packages/compiler/src/server/compile-service.ts

@@ -19,6 +19,7 @@ import {
   joinPaths,
   parse,
 } from "../core/index.js";
+import { builtInLinterLibraryName, builtInLinterRule_UnusedUsing } from "../core/linter.js";
 import { compile as compileProgram } from "../core/program.js";
 import { doIO, loadFile, resolveTspMain } from "../utils/misc.js";
 import { serverOptions } from "./constants.js";
@@ -107,6 +108,17 @@ export function createCompileService({
       ...optionsFromConfig,
       ...serverOptions,
     };
+    // add linter rule for unused using if user didn't configure it explicitly
+    const unusedUsingRule = `${builtInLinterLibraryName}/${builtInLinterRule_UnusedUsing}`;
+    if (
+      options.linterRuleSet?.enable?.[unusedUsingRule] === undefined &&
+      options.linterRuleSet?.disable?.[unusedUsingRule] === undefined
+    ) {
+      options.linterRuleSet ??= {};
+      options.linterRuleSet.enable ??= {};
+      options.linterRuleSet.enable[unusedUsingRule] = true;
+    }
+
     log({ level: "debug", message: `compiler options resolved`, detail: options });
 
     if (!fileService.upToDate(document)) {
@@ -142,7 +154,7 @@ export function createCompileService({
       const script = program.sourceFiles.get(resolvedPath);
       compilerAssert(script, "Failed to get script.");
 
-      const result: CompileResult = { program, document: doc, script };
+      const result: CompileResult = { program, document: doc, script, optionsFromConfig };
       notify("compileEnd", result);
       return result;
     } catch (err: any) {
@@ -180,13 +192,13 @@ export function createCompileService({
     }
 
     const cached = await fileSystemCache.get(configPath);
+    const deepCopy = (obj: any) => JSON.parse(JSON.stringify(obj));
     if (cached?.data) {
-      return cached.data;
+      return deepCopy(cached.data);
     }
 
     const config = await loadTypeSpecConfigFile(compilerHost, configPath);
-    await fileSystemCache.setData(configPath, config);
-    return config;
+    return deepCopy(config);
   }
 
   async function getScript(

packages/compiler/src/server/serverlib.ts

@@ -6,6 +6,7 @@ import {
   CompletionList,
   CompletionParams,
   DefinitionParams,
+  DiagnosticSeverity,
   DiagnosticTag,
   DidChangeWatchedFilesParams,
   DocumentFormattingParams,
@@ -57,6 +58,7 @@ import {
   ResolveModuleHost,
   typespecVersion,
 } from "../core/index.js";
+import { builtInLinterLibraryName, builtInLinterRule_UnusedUsing } from "../core/linter.js";
 import { formatLog } from "../core/logger/index.js";
 import { getPositionBeforeTrivia } from "../core/parser-utils.js";
 import { getNodeAtPosition, getNodeAtPositionDetail, visitChildren } from "../core/parser.js";
@@ -467,7 +469,7 @@ export function createServer(host: ServerHost): Server {
 
     compileService.notifyChange(change.document);
   }
-  async function reportDiagnostics({ program, document }: CompileResult) {
+  async function reportDiagnostics({ program, document, optionsFromConfig }: CompileResult) {
     if (isTspConfigFile(document)) return undefined;
 
     currentDiagnosticIndex.clear();
@@ -495,8 +497,21 @@ export function createServer(host: ServerHost): Server {
             href: each.url,
           };
         }
+        const unusedUsingRule = `${builtInLinterLibraryName}/${builtInLinterRule_UnusedUsing}`;
         if (each.code === "deprecated") {
           diagnostic.tags = [DiagnosticTag.Deprecated];
+        } else if (each.code === unusedUsingRule) {
+          // Unused or unnecessary code. Diagnostics with this tag are rendered faded out, so no extra work needed from IDE side
+          // https://vscode-api.js.org/enums/vscode.DiagnosticTag.html#google_vignette
+          // https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualstudio.languageserver.protocol.diagnostictag?view=visualstudiosdk-2022
+          diagnostic.tags = [DiagnosticTag.Unnecessary];
+          if (
+            optionsFromConfig.linterRuleSet?.enable?.[unusedUsingRule] === undefined &&
+            optionsFromConfig.linterRuleSet?.disable?.[unusedUsingRule] === undefined
+          ) {
+            // if the unused using is not configured by user explicitly, report it as hint by default
+            diagnostic.severity = DiagnosticSeverity.Hint;
+          }
         }
         diagnostic.data = { id: diagnosticIdCounter++ };
         const diagnostics = diagnosticMap.get(diagDocument);