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

.chronus/changes/unused-using-2024-11-27-14-37-20.md

@@ -0,0 +1,14 @@
+---
+changeKind: internal
+packages:
+  - "@typespec/http-specs"
+  - "@typespec/http"
+  - "@typespec/openapi"
+  - "@typespec/openapi3"
+  - "@typespec/rest"
+  - "@typespec/streams"
+  - "@typespec/xml"
+  - "@typespec/http-server-csharp"
+---
+
+Fix test for diagnostics of 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/diagnostics.ts

@@ -33,7 +33,7 @@ export type DiagnosticHandler = (diagnostic: Diagnostic) => void;
 export function logDiagnostics(diagnostics: readonly Diagnostic[], logger: LogSink) {
   for (const diagnostic of diagnostics) {
     logger.log({
-      level: diagnostic.severity,
+      level: diagnostic.severity === "hint" ? "trace" : diagnostic.severity,
       message: diagnostic.message,
       code: diagnostic.code,
       url: diagnostic.url,
@@ -52,7 +52,7 @@ export function formatDiagnostic(diagnostic: Diagnostic, options: FormatDiagnost
   return formatLog(
     {
       code: diagnostic.code,
-      level: diagnostic.severity,
+      level: diagnostic.severity === "hint" ? "trace" : diagnostic.severity,
       message: diagnostic.message,
       url: diagnostic.url,
       sourceLocation: getSourceLocation(diagnostic.target, { locateId: true }),

packages/compiler/src/core/messages.ts

@@ -576,6 +576,12 @@ const diagnostics = {
       default: "The #deprecated directive cannot be used more than once on the same declaration.",
     },
   },
+  "unused-using": {
+    severity: "hint",
+    messages: {
+      default: paramMessage`Unused using: ${"code"}`,
+    },
+  },
 
   /**
    * Configuration

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

@@ -60,7 +60,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,
@@ -94,6 +94,7 @@ import {
   TypeReferenceNode,
   TypeSpecScriptNode,
   UnionStatementNode,
+  UsingStatementNode,
 } from "./types.js";
 
 export interface NameResolver {
@@ -142,6 +143,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 */
@@ -175,6 +179,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);
@@ -222,8 +231,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) ?? [];
   }
@@ -960,6 +994,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);
         }
       }
@@ -997,6 +1040,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

@@ -15,6 +15,7 @@ import { PackageJson } from "../types/package-json.js";
 import { deepEquals, findProjectRoot, isDefined, mapEquals, mutate } from "../utils/misc.js";
 import { createBinder } from "./binder.js";
 import { Checker, createChecker } from "./checker.js";
+import { removeUnusedCodeCodeFix } from "./compiler-code-fixes/remove-unused-code.codefix.js";
 import { createSuppressCodeFix } from "./compiler-code-fixes/suppress.codefix.js";
 import { compilerAssert } from "./diagnostics.js";
 import { resolveTypeSpecEntrypoint } from "./entrypoint-resolution.js";
@@ -45,11 +46,13 @@ import {
   EmitContext,
   EmitterFunc,
   Entity,
+  IdentifierNode,
   JsSourceFileNode,
   LibraryInstance,
   LibraryMetadata,
   LiteralType,
   LocationContext,
+  MemberExpressionNode,
   ModuleLibraryMetadata,
   Namespace,
   NoTarget,
@@ -250,6 +253,8 @@ export async function compile(
     return program;
   }
 
+  validateUnusedCode();
+
   // Linter stage
   program.reportDiagnostics(linter.lint());
 
@@ -260,6 +265,29 @@ export async function compile(
 
   return program;
 
+  function validateUnusedCode() {
+    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;
+      }
+    };
+    resolver.getUnusedUsings().forEach((target) => {
+      reportDiagnostic(
+        createDiagnostic({
+          code: "unused-using",
+          target: target,
+          format: {
+            code: `using ${getUsingName(target.name)}`,
+          },
+          codefixes: [removeUnusedCodeCodeFix(target)],
+        }),
+      );
+    });
+  }
+
   /**
    * Validate the libraries loaded during the compilation process are compatible.
    */

packages/compiler/src/core/types.ts

@@ -2300,7 +2300,7 @@ export interface TemplateInstanceTarget {
 
 export type DiagnosticTarget = TypeSpecDiagnosticTarget | SourceLocation;
 
-export type DiagnosticSeverity = "error" | "warning";
+export type DiagnosticSeverity = "error" | "warning" | "hint";
 
 export interface Diagnostic {
   code: string;
@@ -2529,8 +2529,9 @@ export interface DiagnosticDefinition<M extends DiagnosticMessages> {
    * Diagnostic severity.
    * - `warning` - Suppressable, should be used to represent potential issues but not blocking.
    * - `error` - Non-suppressable, should be used to represent failure to move forward.
+   * - `hint` - Something to hint to a better way of doing it, like proposing a refactoring.
    */
-  readonly severity: "warning" | "error";
+  readonly severity: "warning" | "error" | "hint";
   /** Messages that can be reported with the diagnostic. */
   readonly messages: M;
   /** Short description of the diagnostic */

packages/compiler/src/server/diagnostics.ts

@@ -141,11 +141,13 @@ function getVSLocationWithTypeInfo(
   };
 }
 
-function convertSeverity(severity: "warning" | "error"): DiagnosticSeverity {
+function convertSeverity(severity: "warning" | "error" | "hint"): DiagnosticSeverity {
   switch (severity) {
     case "warning":
       return DiagnosticSeverity.Warning;
     case "error":
       return DiagnosticSeverity.Error;
+    case "hint":
+      return DiagnosticSeverity.Hint;
   }
 }

packages/compiler/src/server/serverlib.ts

@@ -317,7 +317,7 @@ export function createServer(host: ServerHost): Server {
     if (!validationResult.valid) {
       for (const diag of validationResult.diagnostics) {
         log({
-          level: diag.severity,
+          level: diag.severity === "hint" ? "info" : diag.severity,
           message: diag.message,
           detail: {
             code: diag.code,
@@ -490,6 +490,11 @@ export function createServer(host: ServerHost): Server {
         }
         if (each.code === "deprecated") {
           diagnostic.tags = [DiagnosticTag.Deprecated];
+        } else if (each.code === "unused-using") {
+          // 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];
         }
         diagnostic.data = { id: diagnosticIdCounter++ };
         const diagnostics = diagnosticMap.get(diagDocument);

packages/compiler/src/testing/expect.ts

@@ -33,7 +33,7 @@ export interface DiagnosticMatch {
   /**
    * Match the severity.
    */
-  severity?: "error" | "warning";
+  severity?: "error" | "warning" | "hint";
 
   /**
    * Name of the file for this diagnostic.

packages/compiler/src/testing/test-host.ts

@@ -242,7 +242,7 @@ export const StandardTestLibrary: TypeSpecTestLibrary = {
 };
 
 export async function createTestHost(config: TestHostConfig = {}): Promise<TestHost> {
-  const testHost = await createTestHostInternal();
+  const testHost = await createTestHostInternal(config);
   await testHost.addTypeSpecLibrary(StandardTestLibrary);
   if (config.libraries) {
     for (const library of config.libraries) {
@@ -257,7 +257,7 @@ export async function createTestRunner(host?: TestHost): Promise<BasicTestRunner
   return createTestWrapper(testHost);
 }
 
-async function createTestHostInternal(): Promise<TestHost> {
+async function createTestHostInternal(config: TestHostConfig): Promise<TestHost> {
   let program: Program | undefined;
   const libraries: TypeSpecTestLibrary[] = [];
   const testTypes: Record<string, Type> = {};
@@ -315,7 +315,10 @@ async function createTestHostInternal(): Promise<TestHost> {
 
   async function compile(main: string, options: CompilerOptions = {}) {
     const [testTypes, diagnostics] = await compileAndDiagnose(main, options);
-    expectDiagnosticEmpty(diagnostics);
+    const filteredDiagnostics = config.diagnosticFilter
+      ? diagnostics.filter(config.diagnosticFilter)
+      : diagnostics;
+    expectDiagnosticEmpty(filteredDiagnostics);
     return testTypes;
   }
 
@@ -334,10 +337,13 @@ async function createTestHostInternal(): Promise<TestHost> {
     }
     const p = await compileProgram(fileSystem.compilerHost, resolveVirtualPath(mainFile), options);
     program = p;
+    const filteredDiagnostics = config.diagnosticFilter
+      ? p.diagnostics.filter(config.diagnosticFilter)
+      : p.diagnostics;
     logVerboseTestOutput((log) =>
-      logDiagnostics(p.diagnostics, createLogger({ sink: fileSystem.compilerHost.logSink })),
+      logDiagnostics(filteredDiagnostics, createLogger({ sink: fileSystem.compilerHost.logSink })),
     );
-    return [testTypes, p.diagnostics];
+    return [testTypes, filteredDiagnostics];
   }
 }
 

packages/compiler/src/testing/types.ts

@@ -54,6 +54,8 @@ export interface TypeSpecTestLibrary {
 
 export interface TestHostConfig {
   libraries?: TypeSpecTestLibrary[];
+  /** the diagnostics will be ignored if this return false */
+  diagnosticFilter?: (diag: Diagnostic) => boolean;
 }
 
 export class TestHostError extends Error {