support ignoring inspections. (#1326)

wangmingliang-ms · web-flow · commit d6921eb7c458 · 2024-05-20T16:53:48.000+08:00
* feat: support ignore inspections.

* resolve comments.
diff --git a/src/copilot/inspect/InspectActionCodeLensProvider.ts b/src/copilot/inspect/InspectActionCodeLensProvider.ts
@@ -1,6 +1,7 @@
 import { CodeLens, CodeLensProvider, Event, EventEmitter, ExtensionContext, TextDocument, Uri, languages } from "vscode";
 import { getTopLevelClassesOfDocument, logger } from "../utils";
-import { COMMAND_INSPECT_CLASS } from "./commands";
+import { COMMAND_IGNORE_INSPECTIONS, COMMAND_INSPECT_CLASS } from "./commands";
+import InspectionCache from "./InspectionCache";
 
 export class InspectActionCodeLensProvider implements CodeLensProvider {
     private inspectCodeLenses: Map<Uri, CodeLens[]> = new Map();
@@ -18,14 +19,22 @@ export class InspectActionCodeLensProvider implements CodeLensProvider {
     public async rerender(document: TextDocument) {
         if (document.languageId !== 'java') return;
         logger.debug('[InspectCodeLensProvider] rerender inspect codelenses...');
-        const docCodeLenses: CodeLens[] = [];
+        const topLevelCodeLenses: CodeLens[] = [];
         const classes = await getTopLevelClassesOfDocument(document);
-        classes.forEach(clazz => docCodeLenses.push(new CodeLens(clazz.range, {
+        classes.map(clazz => new CodeLens(clazz.range, {
             title: "Rewrite with new syntax",
             command: COMMAND_INSPECT_CLASS,
             arguments: [document, clazz]
-        })));
-        this.inspectCodeLenses.set(document.uri, docCodeLenses);
+        })).forEach(codeLens => topLevelCodeLenses.push(codeLens));
+
+        const results = await Promise.all(classes.map(clazz => InspectionCache.hasCache(document, clazz)));
+        classes.filter((_, i) => results[i]).map(clazz => new CodeLens(clazz.range, {
+            title: "Ignore all",
+            command: COMMAND_IGNORE_INSPECTIONS,
+            arguments: [document, clazz]
+        })).forEach(codeLens => topLevelCodeLenses.push(codeLens));
+
+        this.inspectCodeLenses.set(document.uri, topLevelCodeLenses);
         this.emitter.fire();
     }
 
diff --git a/src/copilot/inspect/Inspection.ts b/src/copilot/inspect/Inspection.ts
@@ -1,4 +1,5 @@
 import { TextDocument, workspace, window, Selection, Range, Position } from "vscode";
+import { SymbolNode } from "./SymbolNode";
 
 export interface InspectionProblem {
     /**
@@ -27,6 +28,7 @@ export interface InspectionProblem {
 
 export interface Inspection {
     document?: TextDocument;
+    symbol?: SymbolNode;
     problem: InspectionProblem;
     solution: string;
     severity: string;
diff --git a/src/copilot/inspect/InspectionCache.ts b/src/copilot/inspect/InspectionCache.ts
@@ -1,5 +1,5 @@
 import { SymbolKind, TextDocument } from 'vscode';
-import { METHOD_KINDS, getClassesAndMethodsOfDocument, logger } from '../utils';
+import { METHOD_KINDS, getClassesAndMethodsContainedInRange, getClassesAndMethodsOfDocument, logger } from '../utils';
 import { Inspection } from './Inspection';
 import * as crypto from "crypto";
 import { SymbolNode } from './SymbolNode';
@@ -11,20 +11,37 @@ import { SymbolNode } from './SymbolNode';
 const DOC_SYMBOL_VERSION_INSPECTIONS: Map<string, Map<string, [string, Inspection[]]>> = new Map();
 
 export default class InspectionCache {
-    public static hasCache(document: TextDocument, symbol?: SymbolNode): boolean {
+    /**
+     * check if the document or the symbol is cached.
+     * if the symbol is provided, check if the symbol or its contained symbols are cached.
+     */
+    public static async hasCache(document: TextDocument, symbol?: SymbolNode): Promise<boolean> {
         const documentKey = document.uri.fsPath;
         if (!symbol) {
             return DOC_SYMBOL_VERSION_INSPECTIONS.has(documentKey);
         }
         const symbolInspections = DOC_SYMBOL_VERSION_INSPECTIONS.get(documentKey);
-        const versionInspections = symbolInspections?.get(symbol.qualifiedName);
-        const symbolVersionId = InspectionCache.calculateSymbolVersionId(document, symbol);
-        return versionInspections?.[0] === symbolVersionId;
+        // check if the symbol or its contained symbols are cached
+        const symbols = await getClassesAndMethodsContainedInRange(symbol.range, document);
+        for (const s of symbols) {
+            const versionInspections = symbolInspections?.get(s.qualifiedName);
+            const symbolVersionId = InspectionCache.calculateSymbolVersionId(document, s);
+            if (versionInspections?.[0] === symbolVersionId) {
+                return true;
+            }
+        }
+        return false;
     }
 
+    /**
+     * Get cached inspections of a document, if the document is not cached, return an empty array.
+     * Cached inspections of outdated symbols are filtered out.Symbols are considered outdated if 
+     * their content has changed.
+     */
     public static async getCachedInspectionsOfDoc(document: TextDocument): Promise<Inspection[]> {
         const symbols: SymbolNode[] = await getClassesAndMethodsOfDocument(document);
         const inspections: Inspection[] = [];
+        // we don't get cached inspections directly from the cache, because we need to filter out outdated symbols
         for (const symbol of symbols) {
             const cachedInspections = InspectionCache.getCachedInspectionsOfSymbol(document, symbol);
             inspections.push(...cachedInspections);
@@ -109,6 +126,10 @@ export default class InspectionCache {
         const documentKey = document.uri.fsPath;
         const symbolVersionId = InspectionCache.calculateSymbolVersionId(document, symbol);
         const cachedSymbolInspections = DOC_SYMBOL_VERSION_INSPECTIONS.get(documentKey) ?? new Map();
+        inspections.forEach(s => {
+            s.document = document;
+            s.symbol = symbol;
+        });
         // use qualified name to prevent conflicts between symbols with the same signature in same document
         cachedSymbolInspections.set(symbol.qualifiedName, [symbolVersionId, inspections]);
         DOC_SYMBOL_VERSION_INSPECTIONS.set(documentKey, cachedSymbolInspections);
diff --git a/src/copilot/inspect/InspectionCopilot.ts b/src/copilot/inspect/InspectionCopilot.ts
@@ -4,7 +4,7 @@ import { getClassesContainedInRange, getInnermostClassContainsRange, getIntersec
 import { Inspection } from "./Inspection";
 import path from "path";
 import { TextDocument, SymbolKind, ProgressLocation, commands, Position, Range, Selection, window, LanguageModelChatSystemMessage, LanguageModelChatMessage, LanguageModelChatUserMessage, LanguageModelChatAssistantMessage } from "vscode";
-import { COMMAND_FIX } from "./commands";
+import { COMMAND_FIX_INSPECTION } from "./commands";
 import InspectionCache from "./InspectionCache";
 import { SymbolNode } from "./SymbolNode";
 
@@ -172,7 +172,7 @@ export default class InspectionCopilot extends Copilot {
                 void window.showInformationMessage(`Inspected ${symbolKind} ${symbolName}... of \"${path.basename(document.fileName)}\" and got 0 suggestions.`);
             } else if (inspections.length == 1) {
                 // apply the only suggestion automatically
-                void commands.executeCommand(COMMAND_FIX, inspections[0].problem, inspections[0].solution, 'auto');
+                void commands.executeCommand(COMMAND_FIX_INSPECTION, inspections[0].problem, inspections[0].solution, 'auto');
             } else {
                 // show message to go to the first suggestion
                 void window.showInformationMessage(`Inspected ${symbolKind} ${symbolName}... of \"${path.basename(document.fileName)}\" and got ${inspections.length} suggestions.`, "Go to").then(selection => {
diff --git a/src/copilot/inspect/commands.ts b/src/copilot/inspect/commands.ts
@@ -5,10 +5,12 @@ import { Inspection, InspectionProblem } from "./Inspection";
 import { uncapitalize } from "../utils";
 import { SymbolNode } from "./SymbolNode";
 import { DocumentRenderer } from "./DocumentRenderer";
+import InspectionCache from "./InspectionCache";
 
 export const COMMAND_INSPECT_CLASS = 'java.copilot.inspect.class';
 export const COMMAND_INSPECT_RANGE = 'java.copilot.inspect.range';
-export const COMMAND_FIX = 'java.copilot.fix.inspection';
+export const COMMAND_FIX_INSPECTION = 'java.copilot.inspection.fix';
+export const COMMAND_IGNORE_INSPECTIONS = 'java.copilot.inspection.ignore';
 
 export function registerCommands(copilot: InspectionCopilot, renderer: DocumentRenderer) {
     instrumentOperationAsVsCodeCommand(COMMAND_INSPECT_CLASS, async (document: TextDocument, clazz: SymbolNode) => {
@@ -21,10 +23,10 @@ export function registerCommands(copilot: InspectionCopilot, renderer: DocumentR
         renderer.rerender(document);
     });
 
-    instrumentOperationAsVsCodeCommand(COMMAND_FIX, async (problem: InspectionProblem, solution: string, source: string) => {
+    instrumentOperationAsVsCodeCommand(COMMAND_FIX_INSPECTION, async (problem: InspectionProblem, solution: string, source: string) => {
         // source is where is this command triggered from, e.g. "gutter", "codelens", "diagnostic"
         const range = Inspection.getIndicatorRangeOfInspection(problem);
-        sendInfo(`${COMMAND_FIX}.info`, { problem: problem.description, solution, source });
+        sendInfo(`${COMMAND_FIX_INSPECTION}.info`, { problem: problem.description, solution, source });
         void commands.executeCommand('vscode.editorChat.start', {
             autoSend: true,
             message: `/fix ${problem.description}, maybe ${uncapitalize(solution)}`,
@@ -33,4 +35,12 @@ export function registerCommands(copilot: InspectionCopilot, renderer: DocumentR
             initialRange: range
         });
     });
+
+    instrumentOperationAsVsCodeCommand(COMMAND_IGNORE_INSPECTIONS, async (document: TextDocument, symbol?: SymbolNode, inspection?: Inspection) => {
+        if (inspection) {
+            sendInfo(`${COMMAND_IGNORE_INSPECTIONS}.info`, { problem: inspection.problem.description, solution: inspection.solution });
+        }
+        InspectionCache.invalidateInspectionCache(document, symbol, inspection);
+        renderer.rerender(document);
+    });
 }
diff --git a/src/copilot/inspect/render/CodeLensRenderer.ts b/src/copilot/inspect/render/CodeLensRenderer.ts
@@ -2,8 +2,9 @@
 import { CodeLens, CodeLensProvider, Disposable, Event, EventEmitter, ExtensionContext, TextDocument, Uri, languages } from "vscode";
 import { Inspection } from "../Inspection";
 import { InspectionRenderer } from "./InspectionRenderer";
-import { logger } from "../../../copilot/utils";
-import { COMMAND_FIX } from "../commands";
+import { logger, uncapitalize } from "../../../copilot/utils";
+import { COMMAND_IGNORE_INSPECTIONS, COMMAND_FIX_INSPECTION } from "../commands";
+import { capitalize } from "lodash";
 
 export class CodeLensRenderer implements InspectionRenderer {
     private readonly codeLenses: Map<Uri, CodeLens[]> = new Map();
@@ -40,7 +41,7 @@ export class CodeLensRenderer implements InspectionRenderer {
         if (inspections.length < 1 || !this.codeLenses) {
             return;
         }
-        const newCodeLenses: CodeLens[] = inspections.map(s => CodeLensRenderer.toCodeLens(s));
+        const newCodeLenses: CodeLens[] = inspections.flatMap(s => CodeLensRenderer.toCodeLenses(document, s));
         const newCodeLensesMessages = newCodeLenses.map(c => c.command?.title.trim());
         const existingCodeLenses = this.codeLenses.get(document.uri) ?? [];
         const leftCodeLenses = existingCodeLenses.filter(c => !newCodeLensesMessages.includes(c.command?.title.trim()));
@@ -49,15 +50,25 @@ export class CodeLensRenderer implements InspectionRenderer {
         this.provider.refresh();
     }
 
-    private static toCodeLens(inspection: Inspection): CodeLens {
+    private static toCodeLenses(document: TextDocument, inspection: Inspection): CodeLens[] {
+        const codeLenses = [];
         const range = Inspection.getIndicatorRangeOfInspection(inspection.problem);
-        const codeLens = new CodeLens(range, {
-            title: inspection.solution,
+        const inspectionCodeLens = new CodeLens(range, {
+            title: capitalize(inspection.solution),
             tooltip: inspection.problem.description,
-            command: COMMAND_FIX,
+            command: COMMAND_FIX_INSPECTION,
             arguments: [inspection.problem, inspection.solution, 'codelenses']
         });
-        return codeLens;
+        codeLenses.push(inspectionCodeLens);
+
+        const ignoreCodeLens = new CodeLens(range, {
+            title: 'Ignore',
+            tooltip: `Ignore "${uncapitalize(inspection.problem.description)}"`,
+            command: COMMAND_IGNORE_INSPECTIONS,
+            arguments: [document, inspection.symbol, inspection]
+        });
+        codeLenses.push(ignoreCodeLens);
+        return codeLenses;
     }
 }
 
diff --git a/src/copilot/inspect/render/DiagnosticRenderer.ts b/src/copilot/inspect/render/DiagnosticRenderer.ts
@@ -2,8 +2,8 @@
 import { CancellationToken, CodeAction, CodeActionContext, CodeActionKind, Diagnostic, DiagnosticCollection, DiagnosticSeverity, ExtensionContext, Range, Selection, TextDocument, languages } from "vscode";
 import { Inspection } from "../Inspection";
 import { InspectionRenderer } from "./InspectionRenderer";
-import { logger } from "../../../copilot/utils";
-import { COMMAND_FIX } from "../commands";
+import { logger, uncapitalize } from "../../../copilot/utils";
+import { COMMAND_IGNORE_INSPECTIONS, COMMAND_FIX_INSPECTION } from "../commands";
 
 const DIAGNOSTICS_GROUP = 'java.copilot.inspection.diagnostics';
 
@@ -69,17 +69,28 @@ export async function fixDiagnostic(document: TextDocument, _range: Range | Sele
         // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         const inspection: Inspection = diagnostic.additional as Inspection;
-        const action: CodeAction = {
+        const fixAction: CodeAction = {
             title: inspection.solution,
             diagnostics: [diagnostic],
             kind: CodeActionKind.RefactorRewrite,
             command: {
                 title: diagnostic.message,
-                command: COMMAND_FIX,
+                command: COMMAND_FIX_INSPECTION,
                 arguments: [inspection.problem, inspection.solution, 'diagnostics']
             }
         };
-        actions.push(action);
+        actions.push(fixAction);
+        const ignoreAction: CodeAction = {
+            title: `Ignore "${uncapitalize(inspection.problem.description)}"`,
+            diagnostics: [diagnostic],
+            kind: CodeActionKind.RefactorRewrite,
+            command: {
+                title: `Ignore "${uncapitalize(inspection.problem.description)}"`,
+                command: COMMAND_IGNORE_INSPECTIONS,
+                arguments: [document, inspection.symbol, inspection]
+            }
+        };
+        actions.push(ignoreAction);
     }
     return actions;
 }
diff --git a/src/copilot/inspect/render/GutterIconRenderer.ts b/src/copilot/inspect/render/GutterIconRenderer.ts
@@ -4,7 +4,7 @@ import { Inspection } from "../Inspection";
 import { InspectionRenderer } from "./InspectionRenderer";
 import { logger } from "../../../copilot/utils";
 import path = require("path");
-import { COMMAND_FIX } from "../commands";
+import { COMMAND_FIX_INSPECTION } from "../commands";
 
 export class GutterIconRenderer implements InspectionRenderer {
     private readonly gutterIcons: Map<Uri, GutterIcon[]> = new Map();
@@ -59,7 +59,7 @@ export class GutterIconRenderer implements InspectionRenderer {
     private static toGutterIcon(inspection: Inspection): GutterIcon {
         const range = Inspection.getIndicatorRangeOfInspection(inspection.problem);
         const args = [inspection.problem, inspection.solution, 'guttericons'];
-        const commandUri = Uri.parse(`command:${COMMAND_FIX}?${encodeURIComponent(JSON.stringify(args))}`);
+        const commandUri = Uri.parse(`command:${COMMAND_FIX_INSPECTION}?${encodeURIComponent(JSON.stringify(args))}`);
         const hoverMessage = new MarkdownString(`${inspection.problem.description}\n\n$(copilot) [${inspection.solution}](${commandUri})`, true);
         hoverMessage.isTrusted = true;
         return { range, hoverMessage, inspection };
diff --git a/src/copilot/utils.ts b/src/copilot/utils.ts
@@ -15,6 +15,11 @@ export async function getClassesContainedInRange(range: Range | Selection, docum
         .filter(clazz => range.contains(clazz.range));
 }
 
+export async function getClassesAndMethodsContainedInRange(range: Range | Selection, document: TextDocument): Promise<SymbolNode[]> {
+    const symbols = await getClassesAndMethodsOfDocument(document);
+    return symbols.filter(symbol => range.contains(symbol.range));
+}
+
 /**
  * get the innermost class symbol that completely contains the `range` in the `document`
  */
