From f13d8407f7f46d6e5c3b3cc0e38552ba994c63b7 Mon Sep 17 00:00:00 2001 From: radurentea Date: Mon, 3 Mar 2025 12:03:15 +0200 Subject: [PATCH 01/16] Add identification of problems --- package.json | 6 ++++-- src/espIdf/hints/index.ts | 4 +++- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/package.json b/package.json index 4a77b2de4..99754ecd1 100644 --- a/package.json +++ b/package.json @@ -277,7 +277,8 @@ "column": 3, "severity": 4, "message": 5 - } + }, + "source": "esp-idf" }, { "name": "espIdfLd", @@ -292,7 +293,8 @@ "file": 1, "line": 2, "message": 3 - } + }, + "source": "esp-idf" } ], "viewsContainers": { diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index dee8c2028..de5dcc66c 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -239,7 +239,9 @@ export class HintHoverProvider implements vscode.HoverProvider { position: vscode.Position, token: vscode.CancellationToken ): vscode.ProviderResult { - const diagnostics = vscode.languages.getDiagnostics(document.uri); + const diagnostics = vscode.languages + .getDiagnostics(document.uri) + .filter((diagnostic) => diagnostic.source === "esp-idf"); for (const diagnostic of diagnostics) { const start = diagnostic.range.start; From d4add074e313f45858f24cc3068ec25e72d189e0 Mon Sep 17 00:00:00 2001 From: radurentea Date: Mon, 3 Mar 2025 15:02:14 +0200 Subject: [PATCH 02/16] Add focus when hint found; Improve hintsviewer --- src/espIdf/hints/index.ts | 78 ++++++++++++++++++++++++++++++++------- src/extension.ts | 55 +++++++++++++-------------- 2 files changed, 93 insertions(+), 40 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index de5dcc66c..2660911c5 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -43,11 +43,28 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { private data: ErrorHint[] = []; public getHintForError(errorMsg: string): string | undefined { + // First try exact match for (const errorHint of this.data) { - if (errorHint.label.includes(errorMsg) && errorHint.children.length > 0) { + if (errorHint.label === errorMsg && errorHint.children.length > 0) { return errorHint.children[0].label; } } + + // Then try partial match + for (const errorHint of this.data) { + // Normalize strings for comparison (trim, lowercase) + const normalizedLabel = errorHint.label.trim().toLowerCase(); + const normalizedError = errorMsg.trim().toLowerCase(); + + // Check if error message is contained in the label or vice versa + if ((normalizedLabel.includes(normalizedError) || + normalizedError.includes(normalizedLabel)) && + errorHint.children.length > 0) { + return errorHint.children[0].label; + } + } + + // No match found return undefined; } @@ -239,27 +256,62 @@ export class HintHoverProvider implements vscode.HoverProvider { position: vscode.Position, token: vscode.CancellationToken ): vscode.ProviderResult { + // Get all diagnostics for this document const diagnostics = vscode.languages .getDiagnostics(document.uri) - .filter((diagnostic) => diagnostic.source === "esp-idf"); + .filter((diagnostic) => + diagnostic.source === "esp-idf" && + diagnostic.severity === vscode.DiagnosticSeverity.Error + ); + + // No ESP-IDF diagnostics found for this document + if (!diagnostics.length) { + return null; + } + // Find diagnostics that contain the hover position for (const diagnostic of diagnostics) { - const start = diagnostic.range.start; - const end = diagnostic.range.end; - - // Check if the position is within or immediately adjacent to the diagnostic range - if ( - diagnostic.severity === vscode.DiagnosticSeverity.Error && - position.line === start.line && - position.character >= start.character - 1 && - position.character <= end.character + 1 - ) { + // Check if position is within the diagnostic range + // We'll be slightly more generous with the range to make it easier to hover + const range = diagnostic.range; + + // Expand the range slightly to make it easier to hover + const lineText = document.lineAt(range.start.line).text; + const expandedRange = new vscode.Range( + new vscode.Position(range.start.line, 0), + new vscode.Position(range.end.line, lineText.length) + ); + + // Check if position is within the expanded range + if (expandedRange.contains(position)) { + // Get hint for this error message const hint = this.hintProvider.getHintForError(diagnostic.message); + if (hint) { - return new vscode.Hover(`ESP-IDF Hint: ${hint}`); + // We found a hint, return it with markdown formatting + return new vscode.Hover( + new vscode.MarkdownString(`**ESP-IDF Hint**: ${hint}`) + ); + } else { + // No hint found, search for one + this.hintProvider.searchError(diagnostic.message, vscode.workspace.workspaceFolders?.[0]) + .then(found => { + // This will happen after the hover is displayed, + // but at least it will update the hint panel for next time + if (found) { + vscode.commands.executeCommand("errorHints.focus"); + } + }); + + // Return basic info that a hint might be available in the panel + return new vscode.Hover( + new vscode.MarkdownString(`Checking for ESP-IDF hints for this error...`) + ); } } } + + // No matching diagnostics found at this position return null; } } diff --git a/src/extension.ts b/src/extension.ts index 67790a829..b3ac3b3a8 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -3683,9 +3683,7 @@ export async function activate(context: vscode.ExtensionContext) { "espressif.esp-idf-extension#espIdf.walkthrough.basic-usage" ); } - // Hints Viewer - const treeDataProvider = new ErrorHintProvider(context); vscode.window.registerTreeDataProvider("errorHints", treeDataProvider); @@ -3699,37 +3697,40 @@ export async function activate(context: vscode.ExtensionContext) { } }); - // Function to process diagnostics and update error hints - const processDiagnostics = async (uri: vscode.Uri) => { - const diagnostics = vscode.languages.getDiagnostics(uri); - - const errorDiagnostics = diagnostics.filter( - (d) => d.severity === vscode.DiagnosticSeverity.Error - ); - - if (errorDiagnostics.length > 0) { - const errorMsg = errorDiagnostics[0].message; - await treeDataProvider.searchError(errorMsg, workspaceRoot); - } else { + // Function to process all ESP-IDF diagnostics from the problems panel + const processEspIdfDiagnostics = async () => { + // Get all diagnostics from all files that have source "esp-idf" + const espIdfDiagnostics: Array<{ uri: vscode.Uri; diagnostic: vscode.Diagnostic }> = []; + + // Collect all diagnostics from all files that have source "esp-idf" + vscode.languages.getDiagnostics().forEach(([uri, diagnostics]) => { + diagnostics + .filter(d => d.source === "esp-idf" && d.severity === vscode.DiagnosticSeverity.Error) + .forEach(diagnostic => { + espIdfDiagnostics.push({ uri, diagnostic }); + }); + }); + + // Clear existing error hints if no ESP-IDF diagnostics + if (espIdfDiagnostics.length === 0) { treeDataProvider.clearErrorHints(); + return; + } + + // Process the first error if available + const errorMsg = espIdfDiagnostics[0].diagnostic.message; + const foundHint = await treeDataProvider.searchError(errorMsg, workspaceRoot); + + // TODO: Create a variable in globalstate to save configuration if focus should be enabled/disabled when diagnostics update + if (foundHint) { + await vscode.commands.executeCommand("errorHints.focus"); } }; // Attach a listener to the diagnostics collection context.subscriptions.push( - vscode.languages.onDidChangeDiagnostics((event) => { - event.uris.forEach((uri) => { - processDiagnostics(uri); - }); - }) - ); - - // Listen to the active text editor change event - context.subscriptions.push( - vscode.window.onDidChangeActiveTextEditor((editor) => { - if (editor) { - processDiagnostics(editor.document.uri); - } + vscode.languages.onDidChangeDiagnostics((_event) => { + processEspIdfDiagnostics(); }) ); From 99c451f9cf4b67ef301615eea2c94366cb773dd8 Mon Sep 17 00:00:00 2001 From: radurentea Date: Mon, 3 Mar 2025 15:23:57 +0200 Subject: [PATCH 03/16] Add openocd hints --- .vscode/settings.json | 5 +- src/espIdf/hints/index.ts | 274 ++++++++++++++++++++++++++------------ 2 files changed, 196 insertions(+), 83 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index dfa4f547b..19a91f870 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -35,5 +35,8 @@ ], "typescript.updateImportsOnFileMove.enabled": "always", "workbench.editor.enablePreview": true, - "iis.configDir": "" + "iis.configDir": "", + "idf.pythonInstallPath": "/opt/homebrew/bin/python3", + "idf.espIdfPath": "/Users/radurentea/esp/v5.4/esp-idf", + "idf.toolsPath": "/Users/radurentea/esp/esptools" } diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index 2660911c5..cceedbff4 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -5,25 +5,31 @@ import * as idfConf from "../../idfConfiguration"; import { Logger } from "../../logger/logger"; import * as utils from "../../utils"; import * as vscode from "vscode"; +import * as path from "path"; +import { OpenOCDManager } from "../openOcd/openOcdManager"; class ReHintPair { re: string; hint: string; match_to_output: boolean; + ref?: string; - constructor(re: string, hint: string, match_to_output: boolean = false) { + constructor(re: string, hint: string, match_to_output: boolean = false, ref?: string) { this.re = re; this.hint = hint; this.match_to_output = match_to_output; + this.ref = ref; } } class ErrorHint { public type: "error" | "hint"; public children: ErrorHint[] = []; + public ref?: string; - constructor(public label: string, type: "error" | "hint") { + constructor(public label: string, type: "error" | "hint", ref?: string) { this.type = type; + this.ref = ref; } addChild(child: ErrorHint) { @@ -42,11 +48,14 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { private data: ErrorHint[] = []; - public getHintForError(errorMsg: string): string | undefined { + public getHintForError(errorMsg: string): { hint?: string, ref?: string } | undefined { // First try exact match for (const errorHint of this.data) { if (errorHint.label === errorMsg && errorHint.children.length > 0) { - return errorHint.children[0].label; + return { + hint: errorHint.children[0].label, + ref: errorHint.children[0].ref + }; } } @@ -60,7 +69,10 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { if ((normalizedLabel.includes(normalizedError) || normalizedError.includes(normalizedLabel)) && errorHint.children.length > 0) { - return errorHint.children[0].label; + return { + hint: errorHint.children[0].label, + ref: errorHint.children[0].ref + }; } } @@ -86,68 +98,50 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return false; } - const hintsPath = getHintsYmlPath(espIdfPath); + // Get paths for both hint files + const idfHintsPath = getIdfHintsYmlPath(espIdfPath); + const openOcdHintsPath = await getOpenOcdHintsYmlPath(workspace); try { - if (!(await pathExists(hintsPath))) { - Logger.infoNotify(`${hintsPath} does not exist.`); - return false; - } - - const fileContents = await readFile(hintsPath, "utf-8"); - const hintsData = yaml.load(fileContents); - - const reHintsPairArray: ReHintPair[] = this.loadHints(hintsData); - this.data = []; let meaningfulHintFound = false; - for (const hintPair of reHintsPairArray) { - const match = new RegExp(hintPair.re, "i").exec(errorMsg); - const regexParts = Array.from(hintPair.re.matchAll(/\(([^)]+)\)/g)) - .map((m) => m[1].split("|")) - .flat() - .map((part) => part.toLowerCase()); - if ( - match || - regexParts.some((part) => errorMsg.toLowerCase().includes(part)) - ) { - let finalHint = hintPair.hint; - if ( - match && - hintPair.match_to_output && - hintPair.hint.includes("{}") - ) { - finalHint = hintPair.hint.replace("{}", match[0]); - } else if (!match && hintPair.hint.includes("{}")) { - const matchedSubstring = regexParts.find((part) => - errorMsg.toLowerCase().includes(part.toLowerCase()) - ); - finalHint = hintPair.hint.replace("{}", matchedSubstring || ""); // Handle case where nothing is matched - } - const error = new ErrorHint(errorMsg, "error"); - const hint = new ErrorHint(finalHint, "hint"); - error.addChild(hint); - this.data.push(error); - if (!finalHint.startsWith("No hints found for")) { - meaningfulHintFound = true; - } + // Process ESP-IDF hints + if (await pathExists(idfHintsPath)) { + try { + const fileContents = await readFile(idfHintsPath, "utf-8"); + const hintsData = yaml.load(fileContents); + const reHintsPairArray: ReHintPair[] = this.loadHints(hintsData); + + meaningfulHintFound = await this.processHints(errorMsg, reHintsPairArray) || meaningfulHintFound; + } catch (error) { + Logger.errorNotify( + `Error processing ESP-IDF hints file (line ${error.mark?.line}): ${error.message}`, + error, + "ErrorHintProvider searchError" + ); } + } else { + Logger.infoNotify(`${idfHintsPath} does not exist.`); } - if (this.data.length === 0) { - for (const hintPair of reHintsPairArray) { - if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { - const error = new ErrorHint(hintPair.re, "error"); - const hint = new ErrorHint(hintPair.hint, "hint"); - error.addChild(hint); - this.data.push(error); - - if (!hintPair.hint.startsWith("No hints found for")) { - meaningfulHintFound = true; - } - } + // Process OpenOCD hints + if (openOcdHintsPath && await pathExists(openOcdHintsPath)) { + try { + const fileContents = await readFile(openOcdHintsPath, "utf-8"); + const hintsData = yaml.load(fileContents); + const reHintsPairArray: ReHintPair[] = this.loadOpenOcdHints(hintsData); + + meaningfulHintFound = await this.processHints(errorMsg, reHintsPairArray) || meaningfulHintFound; + } catch (error) { + Logger.errorNotify( + `Error processing OpenOCD hints file (line ${error.mark?.line}): ${error.message}`, + error, + "ErrorHintProvider searchError" + ); } + } else if (openOcdHintsPath) { + Logger.infoNotify(`${openOcdHintsPath} does not exist.`); } if (!this.data.length) { @@ -160,7 +154,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return meaningfulHintFound; } catch (error) { Logger.errorNotify( - `Error processing hints file (line ${error.mark?.line}): ${error.message}`, + `Error processing hints file: ${error.message}`, error, "ErrorHintProvider searchError" ); @@ -168,6 +162,60 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } + private async processHints(errorMsg: string, reHintsPairArray: ReHintPair[]): Promise { + let meaningfulHintFound = false; + for (const hintPair of reHintsPairArray) { + const match = new RegExp(hintPair.re, "i").exec(errorMsg); + const regexParts = Array.from(hintPair.re.matchAll(/\(([^)]+)\)/g)) + .map((m) => m[1].split("|")) + .flat() + .map((part) => part.toLowerCase()); + if ( + match || + regexParts.some((part) => errorMsg.toLowerCase().includes(part)) + ) { + let finalHint = hintPair.hint; + if ( + match && + hintPair.match_to_output && + hintPair.hint.includes("{}") + ) { + finalHint = hintPair.hint.replace("{}", match[0]); + } else if (!match && hintPair.hint.includes("{}")) { + const matchedSubstring = regexParts.find((part) => + errorMsg.toLowerCase().includes(part.toLowerCase()) + ); + finalHint = hintPair.hint.replace("{}", matchedSubstring || ""); // Handle case where nothing is matched + } + const error = new ErrorHint(errorMsg, "error"); + const hint = new ErrorHint(finalHint, "hint", hintPair.ref); + error.addChild(hint); + this.data.push(error); + + if (!finalHint.startsWith("No hints found for")) { + meaningfulHintFound = true; + } + } + } + + if (this.data.length === 0) { + for (const hintPair of reHintsPairArray) { + if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { + const error = new ErrorHint(hintPair.re, "error"); + const hint = new ErrorHint(hintPair.hint, "hint", hintPair.ref); + error.addChild(hint); + this.data.push(error); + + if (!hintPair.hint.startsWith("No hints found for")) { + meaningfulHintFound = true; + } + } + } + } + + return meaningfulHintFound; + } + private loadHints(hintsArray: any): ReHintPair[] { let reHintsPairArray: ReHintPair[] = []; @@ -200,6 +248,39 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return reHintsPairArray; } + private loadOpenOcdHints(hintsArray: any): ReHintPair[] { + let reHintsPairArray: ReHintPair[] = []; + + for (const entry of hintsArray) { + // Ignore all properties that are not "re", "hint", "match_to_output", "variables" or "ref" + if (entry.variables && entry.variables.length) { + for (const variableSet of entry.variables) { + const reVariables = variableSet.re_variables; + const hintVariables = variableSet.hint_variables; + + let re = this.formatEntry(reVariables, entry.re); + let hint = this.formatEntry(hintVariables, entry.hint); + + reHintsPairArray.push( + new ReHintPair(re, hint, entry.match_to_output, entry.ref) + ); + } + } else { + let re = String(entry.re); + let hint = String(entry.hint); + + if (!entry.match_to_output) { + re = this.formatEntry([], re); + hint = this.formatEntry([], hint); + } + + reHintsPairArray.push(new ReHintPair(re, hint, entry.match_to_output, entry.ref)); + } + } + + return reHintsPairArray; + } + private formatEntry(vars: string[], entry: string): string { let i = 0; while (entry.includes("{}")) { @@ -224,6 +305,11 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } else if (element.type === "hint") { treeItem.label = `💡 ${element.label}`; + + // Add tooltip with reference URL if available + if (element.ref) { + treeItem.tooltip = `${element.label}\n\nReference: ${element.ref}`; + } } return treeItem; @@ -243,9 +329,42 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } -function getHintsYmlPath(espIdfPath: string): string { - const separator = os.platform() === "win32" ? "\\" : "/"; - return `${espIdfPath}${separator}tools${separator}idf_py_actions${separator}hints.yml`; +function getIdfHintsYmlPath(espIdfPath: string): string { + const sep = os.platform() === "win32" ? "\\" : "/"; + return `${espIdfPath}${sep}tools${sep}idf_py_actions${sep}hints.yml`; +} + +async function getOpenOcdHintsYmlPath(workspace: vscode.Uri): Promise { + try { + + const espIdfPath = idfConf.readParameter( + "idf.espIdfPath", + workspace + ) as string; + + const openOCDManager = OpenOCDManager.init() + const version = await openOCDManager.version(); + + if (!version) { + Logger.infoNotify("Could not determine OpenOCD version. Hints file won't be loaded."); + return null; + } + + const sep = os.platform() === "win32" ? "\\" : "/"; + const hintsPath = path.join( + espIdfPath, + `tools${sep}openocd-esp32${sep}${version}${sep}openocd-esp32${sep}share${sep}openocd${sep}espressif${sep}tools${sep}esp_problems_hints.yml` + ); + + return hintsPath; + } catch (error) { + Logger.errorNotify( + `Error getting OpenOCD hints path: ${error.message}`, + error, + "getOpenOcdHintsYmlPath" + ); + return null; + } } export class HintHoverProvider implements vscode.HoverProvider { @@ -284,28 +403,19 @@ export class HintHoverProvider implements vscode.HoverProvider { // Check if position is within the expanded range if (expandedRange.contains(position)) { - // Get hint for this error message - const hint = this.hintProvider.getHintForError(diagnostic.message); + // Get hint object for this error message + const hintInfo = this.hintProvider.getHintForError(diagnostic.message); - if (hint) { - // We found a hint, return it with markdown formatting - return new vscode.Hover( - new vscode.MarkdownString(`**ESP-IDF Hint**: ${hint}`) - ); - } else { - // No hint found, search for one - this.hintProvider.searchError(diagnostic.message, vscode.workspace.workspaceFolders?.[0]) - .then(found => { - // This will happen after the hover is displayed, - // but at least it will update the hint panel for next time - if (found) { - vscode.commands.executeCommand("errorHints.focus"); - } - }); + if (hintInfo && hintInfo.hint) { + let hoverMessage = `**ESP-IDF Hint**: ${hintInfo.hint}`; - // Return basic info that a hint might be available in the panel + // Add reference link if available + if (hintInfo.ref) { + hoverMessage += `\n\n[Reference Documentation](${hintInfo.ref})`; + } + // We found a hint, return it with markdown formatting return new vscode.Hover( - new vscode.MarkdownString(`Checking for ESP-IDF hints for this error...`) + new vscode.MarkdownString(`${hoverMessage}`) ); } } @@ -314,4 +424,4 @@ export class HintHoverProvider implements vscode.HoverProvider { // No matching diagnostics found at this position return null; } -} +} \ No newline at end of file From 7ce5445f092bffeeb94da14f0d80e12e322cb9d6 Mon Sep 17 00:00:00 2001 From: radurentea Date: Mon, 3 Mar 2025 16:12:36 +0200 Subject: [PATCH 04/16] Refactor code; Remove partial matches --- src/espIdf/hints/index.ts | 129 ++++++++++++++++++++------------------ 1 file changed, 67 insertions(+), 62 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index cceedbff4..b7dd25e06 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -14,7 +14,12 @@ class ReHintPair { match_to_output: boolean; ref?: string; - constructor(re: string, hint: string, match_to_output: boolean = false, ref?: string) { + constructor( + re: string, + hint: string, + match_to_output: boolean = false, + ref?: string + ) { this.re = re; this.hint = hint; this.match_to_output = match_to_output; @@ -48,34 +53,19 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { private data: ErrorHint[] = []; - public getHintForError(errorMsg: string): { hint?: string, ref?: string } | undefined { + public getHintForError( + errorMsg: string + ): { hint?: string; ref?: string } | undefined { // First try exact match for (const errorHint of this.data) { if (errorHint.label === errorMsg && errorHint.children.length > 0) { - return { + return { hint: errorHint.children[0].label, - ref: errorHint.children[0].ref + ref: errorHint.children[0].ref, }; } } - - // Then try partial match - for (const errorHint of this.data) { - // Normalize strings for comparison (trim, lowercase) - const normalizedLabel = errorHint.label.trim().toLowerCase(); - const normalizedError = errorMsg.trim().toLowerCase(); - - // Check if error message is contained in the label or vice versa - if ((normalizedLabel.includes(normalizedError) || - normalizedError.includes(normalizedLabel)) && - errorHint.children.length > 0) { - return { - hint: errorHint.children[0].label, - ref: errorHint.children[0].ref - }; - } - } - + // No match found return undefined; } @@ -112,8 +102,10 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { const fileContents = await readFile(idfHintsPath, "utf-8"); const hintsData = yaml.load(fileContents); const reHintsPairArray: ReHintPair[] = this.loadHints(hintsData); - - meaningfulHintFound = await this.processHints(errorMsg, reHintsPairArray) || meaningfulHintFound; + + meaningfulHintFound = + (await this.processHints(errorMsg, reHintsPairArray)) || + meaningfulHintFound; } catch (error) { Logger.errorNotify( `Error processing ESP-IDF hints file (line ${error.mark?.line}): ${error.message}`, @@ -126,13 +118,17 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } // Process OpenOCD hints - if (openOcdHintsPath && await pathExists(openOcdHintsPath)) { + if (openOcdHintsPath && (await pathExists(openOcdHintsPath))) { try { const fileContents = await readFile(openOcdHintsPath, "utf-8"); const hintsData = yaml.load(fileContents); - const reHintsPairArray: ReHintPair[] = this.loadOpenOcdHints(hintsData); - - meaningfulHintFound = await this.processHints(errorMsg, reHintsPairArray) || meaningfulHintFound; + const reHintsPairArray: ReHintPair[] = this.loadOpenOcdHints( + hintsData + ); + + meaningfulHintFound = + (await this.processHints(errorMsg, reHintsPairArray)) || + meaningfulHintFound; } catch (error) { Logger.errorNotify( `Error processing OpenOCD hints file (line ${error.mark?.line}): ${error.message}`, @@ -162,7 +158,10 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } - private async processHints(errorMsg: string, reHintsPairArray: ReHintPair[]): Promise { + private async processHints( + errorMsg: string, + reHintsPairArray: ReHintPair[] + ): Promise { let meaningfulHintFound = false; for (const hintPair of reHintsPairArray) { const match = new RegExp(hintPair.re, "i").exec(errorMsg); @@ -175,11 +174,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { regexParts.some((part) => errorMsg.toLowerCase().includes(part)) ) { let finalHint = hintPair.hint; - if ( - match && - hintPair.match_to_output && - hintPair.hint.includes("{}") - ) { + if (match && hintPair.match_to_output && hintPair.hint.includes("{}")) { finalHint = hintPair.hint.replace("{}", match[0]); } else if (!match && hintPair.hint.includes("{}")) { const matchedSubstring = regexParts.find((part) => @@ -274,7 +269,9 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { hint = this.formatEntry([], hint); } - reHintsPairArray.push(new ReHintPair(re, hint, entry.match_to_output, entry.ref)); + reHintsPairArray.push( + new ReHintPair(re, hint, entry.match_to_output, entry.ref) + ); } } @@ -305,7 +302,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } else if (element.type === "hint") { treeItem.label = `💡 ${element.label}`; - + // Add tooltip with reference URL if available if (element.ref) { treeItem.tooltip = `${element.label}\n\nReference: ${element.ref}`; @@ -330,32 +327,41 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } function getIdfHintsYmlPath(espIdfPath: string): string { - const sep = os.platform() === "win32" ? "\\" : "/"; - return `${espIdfPath}${sep}tools${sep}idf_py_actions${sep}hints.yml`; + return path.join(espIdfPath, "tools", "idf_py_actions", "hints.yml"); } -async function getOpenOcdHintsYmlPath(workspace: vscode.Uri): Promise { +async function getOpenOcdHintsYmlPath( + workspace: vscode.Uri +): Promise { try { - const espIdfPath = idfConf.readParameter( - "idf.espIdfPath", - workspace - ) as string; - - const openOCDManager = OpenOCDManager.init() + "idf.espIdfPath", + workspace + ) as string; + + const openOCDManager = OpenOCDManager.init(); const version = await openOCDManager.version(); - + if (!version) { - Logger.infoNotify("Could not determine OpenOCD version. Hints file won't be loaded."); + Logger.infoNotify( + "Could not determine OpenOCD version. Hints file won't be loaded." + ); return null; } - - const sep = os.platform() === "win32" ? "\\" : "/"; + const hintsPath = path.join( - espIdfPath, - `tools${sep}openocd-esp32${sep}${version}${sep}openocd-esp32${sep}share${sep}openocd${sep}espressif${sep}tools${sep}esp_problems_hints.yml` + espIdfPath, + "tools", + "openocd-esp32", + version, + "openocd-esp32", + "share", + "openocd", + "espressif", + "tools", + "esp_problems_hints.yml" ); - + return hintsPath; } catch (error) { Logger.errorNotify( @@ -378,9 +384,10 @@ export class HintHoverProvider implements vscode.HoverProvider { // Get all diagnostics for this document const diagnostics = vscode.languages .getDiagnostics(document.uri) - .filter((diagnostic) => - diagnostic.source === "esp-idf" && - diagnostic.severity === vscode.DiagnosticSeverity.Error + .filter( + (diagnostic) => + diagnostic.source === "esp-idf" && + diagnostic.severity === vscode.DiagnosticSeverity.Error ); // No ESP-IDF diagnostics found for this document @@ -393,7 +400,7 @@ export class HintHoverProvider implements vscode.HoverProvider { // Check if position is within the diagnostic range // We'll be slightly more generous with the range to make it easier to hover const range = diagnostic.range; - + // Expand the range slightly to make it easier to hover const lineText = document.lineAt(range.start.line).text; const expandedRange = new vscode.Range( @@ -405,18 +412,16 @@ export class HintHoverProvider implements vscode.HoverProvider { if (expandedRange.contains(position)) { // Get hint object for this error message const hintInfo = this.hintProvider.getHintForError(diagnostic.message); - + if (hintInfo && hintInfo.hint) { let hoverMessage = `**ESP-IDF Hint**: ${hintInfo.hint}`; - + // Add reference link if available if (hintInfo.ref) { hoverMessage += `\n\n[Reference Documentation](${hintInfo.ref})`; } // We found a hint, return it with markdown formatting - return new vscode.Hover( - new vscode.MarkdownString(`${hoverMessage}`) - ); + return new vscode.Hover(new vscode.MarkdownString(`${hoverMessage}`)); } } } @@ -424,4 +429,4 @@ export class HintHoverProvider implements vscode.HoverProvider { // No matching diagnostics found at this position return null; } -} \ No newline at end of file +} From ce912264255f9eec40e4a0345d4969426c33c047 Mon Sep 17 00:00:00 2001 From: radurentea Date: Tue, 4 Mar 2025 10:41:27 +0200 Subject: [PATCH 05/16] Remove notification --- src/espIdf/hints/index.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index b7dd25e06..da65fe775 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -137,7 +137,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { ); } } else if (openOcdHintsPath) { - Logger.infoNotify(`${openOcdHintsPath} does not exist.`); + Logger.info(`${openOcdHintsPath} does not exist.`); } if (!this.data.length) { From 6d5952d03d48d13a7e9370ec69b4b5178b3fafdc Mon Sep 17 00:00:00 2001 From: radurentea Date: Thu, 6 Mar 2025 07:32:44 +0200 Subject: [PATCH 06/16] Add openOCD automatic search for hints --- src/espIdf/hints/index.ts | 84 +++++++-- src/espIdf/hints/openocdhint.ts | 323 ++++++++++++++++++++++++++++++++ src/extension.ts | 12 +- 3 files changed, 405 insertions(+), 14 deletions(-) create mode 100644 src/espIdf/hints/openocdhint.ts diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index da65fe775..96a73a0e2 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -1,4 +1,17 @@ -import * as os from "os"; +// Copyright 2025 Espressif Systems (Shanghai) CO LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + import * as yaml from "js-yaml"; import { readFile, pathExists } from "fs-extra"; import * as idfConf from "../../idfConfiguration"; @@ -52,12 +65,14 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { > = this._onDidChangeTreeData.event; private data: ErrorHint[] = []; + private buildErrorData: ErrorHint[] = []; + private openocdErrorData: ErrorHint[] = []; public getHintForError( errorMsg: string ): { hint?: string; ref?: string } | undefined { // First try exact match - for (const errorHint of this.data) { + for (const errorHint of this.buildErrorData) { if (errorHint.label === errorMsg && errorHint.children.length > 0) { return { hint: errorHint.children[0].label, @@ -71,6 +86,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } async searchError(errorMsg: string, workspace): Promise { + this.buildErrorData = []; const espIdfPath = idfConf.readParameter( "idf.espIdfPath", workspace @@ -78,7 +94,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { const version = await utils.getEspIdfFromCMake(espIdfPath); if (utils.compareVersion(version.trim(), "5.0") === -1) { - this.data.push( + this.buildErrorData.push( new ErrorHint( `Error hints feature is not supported in ESP-IDF version ${version}`, "error" @@ -93,7 +109,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { const openOcdHintsPath = await getOpenOcdHintsYmlPath(workspace); try { - this.data = []; + this.buildErrorData = []; let meaningfulHintFound = false; // Process ESP-IDF hints @@ -140,8 +156,8 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { Logger.info(`${openOcdHintsPath} does not exist.`); } - if (!this.data.length) { - this.data.push( + if (!this.buildErrorData.length) { + this.buildErrorData.push( new ErrorHint(`No hints found for ${errorMsg}`, "error") ); } @@ -185,7 +201,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { const error = new ErrorHint(errorMsg, "error"); const hint = new ErrorHint(finalHint, "hint", hintPair.ref); error.addChild(hint); - this.data.push(error); + this.buildErrorData.push(error); if (!finalHint.startsWith("No hints found for")) { meaningfulHintFound = true; @@ -193,13 +209,13 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } - if (this.data.length === 0) { + if (this.buildErrorData.length === 0) { for (const hintPair of reHintsPairArray) { if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { const error = new ErrorHint(hintPair.re, "error"); const hint = new ErrorHint(hintPair.hint, "hint", hintPair.ref); error.addChild(hint); - this.data.push(error); + this.buildErrorData.push(error); if (!hintPair.hint.startsWith("No hints found for")) { meaningfulHintFound = true; @@ -314,16 +330,58 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { getChildren(element?: ErrorHint): Thenable { if (element) { - return Promise.resolve(element.children); // Return children if there's a parent element + return Promise.resolve(element.children); } else { - return Promise.resolve(this.data); + return Promise.resolve([...this.buildErrorData, ...this.openocdErrorData]); } } - clearErrorHints() { - this.data = []; + clearErrorHints(clearOpenOCD: boolean = false) { + this.buildErrorData = []; + if (clearOpenOCD) { + this.openocdErrorData = []; + } this._onDidChangeTreeData.fire(); // Notify the view to refresh } + + /** + * Shows an OpenOCD error hint directly without searching in the hints.yml file + * @param errorMsg The error message + * @param hintMsg The hint message + * @param reference Optional URL reference + * @returns true if the hint was displayed, false otherwise + */ + public async showOpenOCDErrorHint( + errorMsg: string, + hintMsg: string, + reference?: string + ): Promise { + try { + this.openocdErrorData = []; + + // Create error and hint nodes + const error = new ErrorHint(errorMsg, "error"); + const hint = new ErrorHint(hintMsg, "hint", reference); + + // Add hint as child of error + error.addChild(hint); + + // Add to the data array + this.openocdErrorData.push(error); + + // Notify that the tree data has changed + this._onDidChangeTreeData.fire(); + + return true; + } catch (error) { + Logger.errorNotify( + `Error showing OpenOCD error hint: ${error.message}`, + error, + "ErrorHintProvider showOpenOCDErrorHint" + ); + return false; + } + } } function getIdfHintsYmlPath(espIdfPath: string): string { diff --git a/src/espIdf/hints/openocdhint.ts b/src/espIdf/hints/openocdhint.ts new file mode 100644 index 000000000..a0b5eb491 --- /dev/null +++ b/src/espIdf/hints/openocdhint.ts @@ -0,0 +1,323 @@ +// Copyright 2025 Espressif Systems (Shanghai) CO LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import * as vscode from "vscode"; +import * as yaml from "js-yaml"; +import { readFile, pathExists } from "fs-extra"; +import * as path from "path"; +import * as idfConf from "../../idfConfiguration"; +import { Logger } from "../../logger/logger"; +import { OutputChannel } from "../../logger/outputChannel"; +import { OpenOCDManager } from "../openOcd/openOcdManager"; +import { ErrorHintProvider } from "./index"; + +interface OpenOCDHint { + source?: string; + re: string; + hint: string; + ref?: string; + match_to_output?: boolean; + variables?: Array<{ + re_variables: string[]; + hint_variables: string[]; + }>; +} + +export class OpenOCDErrorMonitor { + private static instance: OpenOCDErrorMonitor; + private errorHintProvider: ErrorHintProvider; + private hintsData: OpenOCDHint[] = []; + private errorBuffer: string[] = []; + private workspaceRoot: vscode.Uri; + private debounceTimer: NodeJS.Timeout | null = null; + private openOCDLogWatcher: vscode.Disposable | null = null; + private readonly DEBOUNCE_TIME = 300; // ms + + private constructor( + errorHintProvider: ErrorHintProvider, + workspaceRoot: vscode.Uri + ) { + this.errorHintProvider = errorHintProvider; + this.workspaceRoot = workspaceRoot; + } + + public static init( + errorHintProvider: ErrorHintProvider, + workspaceRoot: vscode.Uri + ): OpenOCDErrorMonitor { + if (!OpenOCDErrorMonitor.instance) { + OpenOCDErrorMonitor.instance = new OpenOCDErrorMonitor( + errorHintProvider, + workspaceRoot + ); + } + return OpenOCDErrorMonitor.instance; + } + + public async initialize(): Promise { + try { + // Load OpenOCD hints data + const toolsPath = idfConf.readParameter( + "idf.toolsPath", + this.workspaceRoot + ) as string; + + const openOcdHintsPath = await this.getOpenOcdHintsYmlPath(toolsPath); + + if (openOcdHintsPath && (await pathExists(openOcdHintsPath))) { + try { + const fileContents = await readFile(openOcdHintsPath, "utf-8"); + this.hintsData = yaml.load(fileContents) as OpenOCDHint[]; + Logger.info(`Loaded OpenOCD hints from ${openOcdHintsPath}`); + } catch (error) { + Logger.errorNotify( + `Error processing OpenOCD hints file: ${error.message}`, + error, + "OpenOCDErrorMonitor initialize" + ); + } + } else { + Logger.info(`OpenOCD hints file not found at ${openOcdHintsPath}`); + } + + // Start monitoring OpenOCD output + this.watchOpenOCDStatus(); + } catch (error) { + Logger.errorNotify( + `Error initializing OpenOCD error monitor: ${error.message}`, + error, + "OpenOCDErrorMonitor initialize" + ); + } + } + + public dispose(): void { + if (this.openOCDLogWatcher) { + this.openOCDLogWatcher.dispose(); + this.openOCDLogWatcher = null; + } + + if (this.debounceTimer) { + clearTimeout(this.debounceTimer); + this.debounceTimer = null; + } + } + + private async getOpenOcdHintsYmlPath(toolsPath: string): Promise { + try { + const openOCDManager = OpenOCDManager.init(); + const version = await openOCDManager.version(); + + if (!version) { + Logger.info( + "Could not determine OpenOCD version. Hints file won't be loaded." + ); + return null; + } + + const hintsPath = path.join( + toolsPath, + "tools", + "openocd-esp32", + version, + "openocd-esp32", + "share", + "openocd", + "espressif", + "tools", + "esp_problems_hints.yml" + ); + + return hintsPath; + } catch (error) { + Logger.errorNotify( + `Error getting OpenOCD hints path: ${error.message}`, + error, + "getOpenOcdHintsYmlPath" + ); + return null; + } + } + + private watchOpenOCDStatus(): void { + // Set up watcher for OpenOCD output + if (this.openOCDLogWatcher) { + this.openOCDLogWatcher.dispose(); + } + + const openOCDManager = OpenOCDManager.init(); + + // Add event listener to OpenOCDManager to detect when there's new output + openOCDManager.on("data", (data) => { + const content = data.toString(); + this.processOutput(content); + }); + + openOCDManager.on("error", (error, data) => { + const content = data ? data.toString() : error.message; + this.processOutput(content); + }); + + this.openOCDLogWatcher = { + dispose: () => { + openOCDManager.removeAllListeners("data"); + openOCDManager.removeAllListeners("error"); + } + }; + } + + private processOutput(content: string): void { + if (!content) return; + + // Split into lines and process each line + const lines = content.split('\n'); + + for (const line of lines) { + this.processOutputLine(line.trim()); + } + } + + public processOutputLine(line: string): void { + // Skip empty lines + if (!line) return; + + // Add line to buffer + this.errorBuffer.push(line); + + // Keep the buffer at a reasonable size (last 100 lines) + if (this.errorBuffer.length > 100) { + this.errorBuffer.shift(); + } + + // Check for OpenOCD error patterns in the recent output + if (line.includes("Error:") || line.includes("Warn:")) { + this.debouncedAnalyzeErrors(); + } + } + + private debouncedAnalyzeErrors(): void { + // Debounce to avoid excessive processing + if (this.debounceTimer) { + clearTimeout(this.debounceTimer); + } + + this.debounceTimer = setTimeout(() => { + this.analyzeErrors(); + }, this.DEBOUNCE_TIME); + } + + private async analyzeErrors(): Promise { + try { + // Get the last few lines of context that might contain errors + const context = this.errorBuffer.join("\n"); + + // Look for error patterns + for (const hint of this.hintsData) { + // Skip if the hint is for a specific source that doesn't match + if (hint.source && hint.source !== 'ocd') { + continue; + } + + // Process variables if they exist + if (hint.variables && hint.variables.length > 0) { + let foundMatch = false; + + for (const variableSet of hint.variables) { + const reVariables = variableSet.re_variables; + const hintVariables = variableSet.hint_variables; + + let re = this.formatEntry(reVariables, hint.re); + let hintMsg = this.formatEntry(hintVariables, hint.hint); + + const regex = new RegExp(re, 'i'); + const match = regex.exec(context); + + if (match) { + // Format the hint message if match_to_output is true + if (hint.match_to_output && match.length > 0 && hintMsg.includes("{}")) { + hintMsg = hintMsg.replace("{}", match[0]); + } + + // Show the error hint + await this.showErrorHint(match[0], hintMsg, hint.ref); + foundMatch = true; + break; + } + } + + if (foundMatch) break; + } else { + // No variables, just check the regex directly + const regex = new RegExp(hint.re, 'i'); + const match = regex.exec(context); + + if (match) { + // Format the hint message + let hintMessage = hint.hint; + + if (hint.match_to_output && match.length > 0 && hintMessage.includes("{}")) { + hintMessage = hintMessage.replace("{}", match[0]); + } + + // Trigger the error hint display + await this.showErrorHint(match[0], hintMessage, hint.ref); + + // Only show one hint at a time to avoid overwhelming the user + break; + } + } + } + } catch (error) { + Logger.errorNotify( + `Error analyzing OpenOCD output: ${error.message}`, + error, + "analyzeErrors" + ); + } + } + + private formatEntry(vars: string[], entry: string): string { + let formattedEntry = entry; + + // Replace numbered placeholders with variables + let i = 0; + while (formattedEntry.includes("{}")) { + formattedEntry = formattedEntry.replace("{}", `{${i++}}`); + } + + // Replace {n} with corresponding variable from vars array + formattedEntry = formattedEntry.replace(/\{(\d+)\}/g, (match, idx) => { + const index = parseInt(idx, 10); + return index < vars.length ? vars[index] : ""; + }); + + return formattedEntry; + } + + private async showErrorHint(errorMessage: string, hintMessage: string, reference?: string): Promise { + try { + // Use the existing error hint provider to display the hint + await this.errorHintProvider.showOpenOCDErrorHint(errorMessage, hintMessage, reference); + + // Focus the error hints view + await vscode.commands.executeCommand("errorHints.focus"); + } catch (error) { + Logger.errorNotify( + `Error showing OpenOCD error hint: ${error.message}`, + error, + "showErrorHint" + ); + } + } +} \ No newline at end of file diff --git a/src/extension.ts b/src/extension.ts index b3ac3b3a8..edcaad42d 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -173,6 +173,7 @@ import { } from "./cmdTreeView/cmdStore"; import { IdfSetup } from "./views/setup/types"; import { asyncRemoveEspIdfSettings } from "./uninstall"; +import { OpenOCDErrorMonitor } from "./espIdf/hints/openocdhint"; // Global variables shared by commands let workspaceRoot: vscode.Uri; @@ -3687,6 +3688,9 @@ export async function activate(context: vscode.ExtensionContext) { const treeDataProvider = new ErrorHintProvider(context); vscode.window.registerTreeDataProvider("errorHints", treeDataProvider); + const openOCDErrorMonitor = OpenOCDErrorMonitor.init(treeDataProvider, workspaceRoot); + await openOCDErrorMonitor.initialize(); + vscode.commands.registerCommand("espIdf.searchError", async () => { const errorMsg = await vscode.window.showInputBox({ placeHolder: "Enter the error message", @@ -3713,7 +3717,7 @@ export async function activate(context: vscode.ExtensionContext) { // Clear existing error hints if no ESP-IDF diagnostics if (espIdfDiagnostics.length === 0) { - treeDataProvider.clearErrorHints(); + treeDataProvider.clearErrorHints(false); return; } @@ -3727,6 +3731,12 @@ export async function activate(context: vscode.ExtensionContext) { } }; + context.subscriptions.push({ + dispose: () => { + openOCDErrorMonitor.dispose(); + } + }); + // Attach a listener to the diagnostics collection context.subscriptions.push( vscode.languages.onDidChangeDiagnostics((_event) => { From 0b87079eaafd02058e4d67b32fee83350a4b5db0 Mon Sep 17 00:00:00 2001 From: radurentea Date: Thu, 6 Mar 2025 08:01:29 +0200 Subject: [PATCH 07/16] improve: Display clickable links --- src/espIdf/hints/index.ts | 25 ++++++++++++++++++++++--- 1 file changed, 22 insertions(+), 3 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index 96a73a0e2..7c405496c 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -41,11 +41,11 @@ class ReHintPair { } class ErrorHint { - public type: "error" | "hint"; + public type: "error" | "hint" | "reference"; public children: ErrorHint[] = []; public ref?: string; - constructor(public label: string, type: "error" | "hint", ref?: string) { + constructor(public label: string, type: "error" | "hint" | "reference", ref?: string) { this.type = type; this.ref = ref; } @@ -321,8 +321,21 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { // Add tooltip with reference URL if available if (element.ref) { - treeItem.tooltip = `${element.label}\n\nReference: ${element.ref}`; + treeItem.tooltip = `${element.label}`; + + // If this hint has a reference, make it expandable + treeItem.collapsibleState = vscode.TreeItemCollapsibleState.Expanded; } + } else if (element.type === "reference") { + // Special handling for reference items + treeItem.label = `🔗 Reference Documentation`; + treeItem.tooltip = `Open ${element.label}`; + treeItem.command = { + command: 'vscode.open', + title: 'Open Reference', + arguments: [vscode.Uri.parse(element.label)] + }; + treeItem.iconPath = new vscode.ThemeIcon("link-external"); } return treeItem; @@ -365,6 +378,12 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { // Add hint as child of error error.addChild(hint); + + // If there's a reference, add it as a child of the hint + if (reference) { + const refItem = new ErrorHint(reference, "reference"); + hint.addChild(refItem); + } // Add to the data array this.openocdErrorData.push(error); From 2f8627537d78f32c46ceb20f45b97712925ec935 Mon Sep 17 00:00:00 2001 From: radurentea Date: Fri, 7 Mar 2025 16:12:43 +0200 Subject: [PATCH 08/16] Add button to clear hints - Refactor code - Add Translations --- l10n/bundle.l10n.es.json | 4 +- l10n/bundle.l10n.pt.json | 4 +- l10n/bundle.l10n.ru.json | 4 +- l10n/bundle.l10n.zh-CN.json | 4 +- package.json | 37 +++- src/espIdf/hints/index.ts | 411 ++++++++++++++++++++---------------- src/extension.ts | 59 ++++-- 7 files changed, 315 insertions(+), 208 deletions(-) diff --git a/l10n/bundle.l10n.es.json b/l10n/bundle.l10n.es.json index 06572d418..d36df9a5f 100644 --- a/l10n/bundle.l10n.es.json +++ b/l10n/bundle.l10n.es.json @@ -207,5 +207,7 @@ "Warning: Could not fully remove setting {0}: {1}": "Advertencia: No se pudo eliminar completamente la configuración {0}: {1}", "ESP-IDF settings removed successfully.": "Configuraciones de ESP-IDF eliminadas exitosamente.", "Failed to remove settings: {0}": "Error al eliminar las configuraciones: {0}", - "Error: {0}": "Error: {0}" + "Error: {0}": "Error: {0}", + "🔗 Reference Documentation": "🔗 Documentación de Referencia", + "Open {0}": "Abrir {0}" } diff --git a/l10n/bundle.l10n.pt.json b/l10n/bundle.l10n.pt.json index 5dfb64f34..a2fb088c4 100644 --- a/l10n/bundle.l10n.pt.json +++ b/l10n/bundle.l10n.pt.json @@ -207,5 +207,7 @@ "Warning: Could not fully remove setting {0}: {1}": "Aviso: Não foi possível remover completamente a configuração {0}: {1}", "ESP-IDF settings removed successfully.": "Configurações ESP-IDF removidas com sucesso.", "Failed to remove settings: {0}": "Falha ao remover configurações: {0}", - "Error: {0}": "Erro: {0}" + "Error: {0}": "Erro: {0}", + "🔗 Reference Documentation": "🔗Documentação de Referência", + "Open {0}": "Abrir {0}" } diff --git a/l10n/bundle.l10n.ru.json b/l10n/bundle.l10n.ru.json index 48cd8e27e..f8b85d6b3 100644 --- a/l10n/bundle.l10n.ru.json +++ b/l10n/bundle.l10n.ru.json @@ -207,5 +207,7 @@ "Warning: Could not fully remove setting {0}: {1}": "Предупреждение: Не удалось полностью удалить настройку {0}: {1}", "ESP-IDF settings removed successfully.": "Настройки ESP-IDF успешно удалены.", "Failed to remove settings: {0}": "Не удалось удалить настройки: {0}", - "Error: {0}": "Ошибка: {0}" + "Error: {0}": "Ошибка: {0}", + "🔗 Reference Documentation": "🔗 Справочная Документация", + "Open {0}": "Открыть {0}" } diff --git a/l10n/bundle.l10n.zh-CN.json b/l10n/bundle.l10n.zh-CN.json index a60713862..2725d3d7d 100644 --- a/l10n/bundle.l10n.zh-CN.json +++ b/l10n/bundle.l10n.zh-CN.json @@ -207,5 +207,7 @@ "Warning: Could not fully remove setting {0}: {1}": "警告：无法完全删除设置 {0}：{1}", "ESP-IDF settings removed successfully.": "ESP-IDF设置已成功删除。", "Failed to remove settings: {0}": "删除设置失败：{0}", - "Error: {0}": "错误：{0}" + "Error: {0}": "错误：{0}", + "🔗 Reference Documentation": "🔗 参考文档", + "Open {0}": "打开 {0}" } diff --git a/package.json b/package.json index 99754ecd1..d10f543a1 100644 --- a/package.json +++ b/package.json @@ -400,6 +400,11 @@ } ], "view/title": [ + { + "command": "espIdf.errorHints.clearAll", + "when": "view == errorHints", + "group": "navigation" + }, { "command": "espIdf.searchError", "group": "navigation", @@ -446,6 +451,14 @@ } ], "view/item/context": [ + { + "command": "espIdf.errorHints.clearBuildErrors", + "when": "view == errorHints && viewItem == buildError" + }, + { + "command": "espIdf.errorHints.clearOpenOCDErrors", + "when": "view == errorHints && viewItem == openocdError" + }, { "command": "esp.rainmaker.backend.logout", "when": "view == espRainmaker && viewItem == account", @@ -1201,6 +1214,24 @@ } ], "commands": [ + { + "command": "espIdf.errorHints.clearAll", + "title": "Clear All Error Hints", + "icon": "$(clear-all)", + "category": "ESP-IDF" + }, + { + "command": "espIdf.errorHints.clearBuildErrors", + "title": "Clear Build Error Hints", + "icon": "$(trash)", + "category": "ESP-IDF" + }, + { + "command": "espIdf.errorHints.clearOpenOCDErrors", + "title": "Clear OpenOCD Error Hints", + "icon": "$(trash)", + "category": "ESP-IDF" + }, { "command": "espIdf.removeEspIdfSettings", "title": "%espIdf.removeEspIdfSettings.title%", @@ -1208,11 +1239,13 @@ }, { "command": "espIdf.openWalkthrough", - "title": "ESP-IDF: Open Get Started Walkthrough" + "title": "ESP-IDF: Open Get Started Walkthrough", + "category": "ESP-IDF" }, { "command": "espIdf.searchError", - "title": "%espIdf.searchError.title%" + "title": "%espIdf.searchError.title%", + "category": "ESP-IDF" }, { "command": "espIdf.createFiles", diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index 7c405496c..a58f8fcc0 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -40,62 +40,140 @@ class ReHintPair { } } -class ErrorHint { - public type: "error" | "hint" | "reference"; - public children: ErrorHint[] = []; - public ref?: string; - - constructor(public label: string, type: "error" | "hint" | "reference", ref?: string) { - this.type = type; - this.ref = ref; - } +export class ErrorHintTreeItem extends vscode.TreeItem { + constructor( + public readonly label: string, + public readonly type: "error" | "hint" | "reference", + public readonly children: ErrorHintTreeItem[] = [], + public readonly reference?: string + ) { + super( + label, + children.length > 0 + ? vscode.TreeItemCollapsibleState.Expanded + : vscode.TreeItemCollapsibleState.None + ); - addChild(child: ErrorHint) { - this.children.push(child); + // Set different appearances based on the type + if (type === "error") { + if (label.startsWith("No hints found")) { + this.label = `⚠️ ${label}`; + } else { + this.label = `🔍 ${label}`; + } + } else if (type === "hint") { + this.label = `💡 ${label}`; + this.tooltip = label; + } else if (type === "reference") { + this.label = vscode.l10n.t(`🔗 Reference Documentation`); + this.tooltip = vscode.l10n.t(`Open {0}`, label); + this.command = { + command: 'vscode.open', + title: 'Open Reference', + arguments: [vscode.Uri.parse(label)] + }; + this.iconPath = new vscode.ThemeIcon("link-external"); + } } } -export class ErrorHintProvider implements vscode.TreeDataProvider { - constructor(private context: vscode.ExtensionContext) {} +export class ErrorHintProvider implements vscode.TreeDataProvider { private _onDidChangeTreeData: vscode.EventEmitter< - ErrorHint | undefined | null | void - > = new vscode.EventEmitter(); + ErrorHintTreeItem | undefined | null | void + > = new vscode.EventEmitter(); + readonly onDidChangeTreeData: vscode.Event< - ErrorHint | undefined | null | void + ErrorHintTreeItem | undefined | null | void > = this._onDidChangeTreeData.event; - private data: ErrorHint[] = []; - private buildErrorData: ErrorHint[] = []; - private openocdErrorData: ErrorHint[] = []; + private buildErrorData: ErrorHintTreeItem[] = []; + private openocdErrorData: ErrorHintTreeItem[] = []; - public getHintForError( - errorMsg: string - ): { hint?: string; ref?: string } | undefined { - // First try exact match - for (const errorHint of this.buildErrorData) { - if (errorHint.label === errorMsg && errorHint.children.length > 0) { - return { - hint: errorHint.children[0].label, - ref: errorHint.children[0].ref, - }; - } + constructor(private context: vscode.ExtensionContext) {} + + // Get tree item for display + getTreeItem(element: ErrorHintTreeItem): vscode.TreeItem { + return element; + } + + // Get children of a tree item + getChildren(element?: ErrorHintTreeItem): Thenable { + if (element) { + return Promise.resolve(element.children); + } else { + return Promise.resolve([...this.buildErrorData, ...this.openocdErrorData]); } + } - // No match found - return undefined; + // Clear error hints + clearErrorHints(clearOpenOCD: boolean = false): void { + this.buildErrorData = []; + if (clearOpenOCD) { + this.openocdErrorData = []; + } + this._onDidChangeTreeData.fire(); + } + + // Clear only OpenOCD errors + clearOpenOCDErrorsOnly(): void { + this.openocdErrorData = []; + this._onDidChangeTreeData.fire(); + } + + // Show OpenOCD error hint + public async showOpenOCDErrorHint( + errorMsg: string, + hintMsg: string, + reference?: string + ): Promise { + try { + this.openocdErrorData = []; + + // Create hint nodes + const hintItems: ErrorHintTreeItem[] = []; + + // Add reference as a child if available + if (reference) { + hintItems.push(new ErrorHintTreeItem(reference, "reference")); + } + + // Create hint with children + const hint = new ErrorHintTreeItem(hintMsg, "hint", hintItems); + + // Create error with hint as child + const error = new ErrorHintTreeItem(errorMsg, "error", [hint]); + + // Add to OpenOCD data array + this.openocdErrorData.push(error); + + // Notify that the tree data has changed + this._onDidChangeTreeData.fire(); + + return true; + } catch (error) { + Logger.errorNotify( + `Error showing OpenOCD error hint: ${error.message}`, + error, + "ErrorHintProvider showOpenOCDErrorHint" + ); + return false; + } } - async searchError(errorMsg: string, workspace): Promise { + // Method to search for error hints + public async searchError(errorMsg: string, workspace: vscode.Uri): Promise { this.buildErrorData = []; + const espIdfPath = idfConf.readParameter( "idf.espIdfPath", workspace ) as string; + const version = await utils.getEspIdfFromCMake(espIdfPath); if (utils.compareVersion(version.trim(), "5.0") === -1) { this.buildErrorData.push( - new ErrorHint( + new ErrorHintTreeItem( `Error hints feature is not supported in ESP-IDF version ${version}`, "error" ) @@ -109,7 +187,6 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { const openOcdHintsPath = await getOpenOcdHintsYmlPath(workspace); try { - this.buildErrorData = []; let meaningfulHintFound = false; // Process ESP-IDF hints @@ -156,9 +233,9 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { Logger.info(`${openOcdHintsPath} does not exist.`); } - if (!this.buildErrorData.length) { + if (this.buildErrorData.length === 0) { this.buildErrorData.push( - new ErrorHint(`No hints found for ${errorMsg}`, "error") + new ErrorHintTreeItem(`No hints found for ${errorMsg}`, "error") ); } @@ -174,22 +251,26 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } + // Process hints private async processHints( errorMsg: string, reHintsPairArray: ReHintPair[] ): Promise { let meaningfulHintFound = false; + for (const hintPair of reHintsPairArray) { const match = new RegExp(hintPair.re, "i").exec(errorMsg); const regexParts = Array.from(hintPair.re.matchAll(/\(([^)]+)\)/g)) .map((m) => m[1].split("|")) .flat() .map((part) => part.toLowerCase()); + if ( match || regexParts.some((part) => errorMsg.toLowerCase().includes(part)) ) { let finalHint = hintPair.hint; + if (match && hintPair.match_to_output && hintPair.hint.includes("{}")) { finalHint = hintPair.hint.replace("{}", match[0]); } else if (!match && hintPair.hint.includes("{}")) { @@ -198,9 +279,22 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { ); finalHint = hintPair.hint.replace("{}", matchedSubstring || ""); // Handle case where nothing is matched } - const error = new ErrorHint(errorMsg, "error"); - const hint = new ErrorHint(finalHint, "hint", hintPair.ref); - error.addChild(hint); + + // Create hint children + const hintChildren: ErrorHintTreeItem[] = []; + + // Add reference as child if available + if (hintPair.ref) { + hintChildren.push(new ErrorHintTreeItem(hintPair.ref, "reference")); + } + + // Create hint with children + const hint = new ErrorHintTreeItem(finalHint, "hint", hintChildren, hintPair.ref); + + // Create error with hint as child + const error = new ErrorHintTreeItem(errorMsg, "error", [hint]); + + // Add to build error data this.buildErrorData.push(error); if (!finalHint.startsWith("No hints found for")) { @@ -209,12 +303,25 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } + // If no direct matches, try partial matches if (this.buildErrorData.length === 0) { for (const hintPair of reHintsPairArray) { if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { - const error = new ErrorHint(hintPair.re, "error"); - const hint = new ErrorHint(hintPair.hint, "hint", hintPair.ref); - error.addChild(hint); + // Create hint children + const hintChildren: ErrorHintTreeItem[] = []; + + // Add reference as child if available + if (hintPair.ref) { + hintChildren.push(new ErrorHintTreeItem(hintPair.ref, "reference")); + } + + // Create hint with children + const hint = new ErrorHintTreeItem(hintPair.hint, "hint", hintChildren, hintPair.ref); + + // Create error with hint as child + const error = new ErrorHintTreeItem(hintPair.re, "error", [hint]); + + // Add to build error data this.buildErrorData.push(error); if (!hintPair.hint.startsWith("No hints found for")) { @@ -227,6 +334,36 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return meaningfulHintFound; } + // Get hint for an error message + public getHintForError( + errorMsg: string + ): { hint?: string; ref?: string } | undefined { + // Check in build errors + for (const errorHint of this.buildErrorData) { + if (errorHint.label === errorMsg && errorHint.children.length > 0) { + const hintItem = errorHint.children[0]; + return { + hint: hintItem.label.replace(/^💡 /, ''), + ref: hintItem.reference + }; + } + } + + // Check in OpenOCD errors + for (const errorHint of this.openocdErrorData) { + if (errorHint.label === errorMsg && errorHint.children.length > 0) { + const hintItem = errorHint.children[0]; + return { + hint: hintItem.label.replace(/^💡 /, ''), + ref: hintItem.reference + }; + } + } + + // No match found + return undefined; + } + private loadHints(hintsArray: any): ReHintPair[] { let reHintsPairArray: ReHintPair[] = []; @@ -305,101 +442,63 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { ); return result; } +} - getTreeItem(element: ErrorHint): vscode.TreeItem { - let treeItem = new vscode.TreeItem(element.label); +export class HintHoverProvider implements vscode.HoverProvider { + constructor(private hintProvider: ErrorHintProvider) {} - if (element.type === "error") { - if (element.label.startsWith("No hints found")) { - treeItem.label = `⚠️ ${element.label}`; - } else { - treeItem.label = `🔍 ${element.label}`; - treeItem.collapsibleState = vscode.TreeItemCollapsibleState.Expanded; // Ensure errors are expanded by default - } - } else if (element.type === "hint") { - treeItem.label = `💡 ${element.label}`; + provideHover( + document: vscode.TextDocument, + position: vscode.Position, + token: vscode.CancellationToken + ): vscode.ProviderResult { + // Get all diagnostics for this document + const diagnostics = vscode.languages + .getDiagnostics(document.uri) + .filter( + (diagnostic) => + diagnostic.source === "esp-idf" && + diagnostic.severity === vscode.DiagnosticSeverity.Error + ); - // Add tooltip with reference URL if available - if (element.ref) { - treeItem.tooltip = `${element.label}`; - - // If this hint has a reference, make it expandable - treeItem.collapsibleState = vscode.TreeItemCollapsibleState.Expanded; - } - } else if (element.type === "reference") { - // Special handling for reference items - treeItem.label = `🔗 Reference Documentation`; - treeItem.tooltip = `Open ${element.label}`; - treeItem.command = { - command: 'vscode.open', - title: 'Open Reference', - arguments: [vscode.Uri.parse(element.label)] - }; - treeItem.iconPath = new vscode.ThemeIcon("link-external"); + // No ESP-IDF diagnostics found for this document + if (!diagnostics.length) { + return null; } - return treeItem; - } + // Find diagnostics that contain the hover position + for (const diagnostic of diagnostics) { + // Check if position is within the diagnostic range + // We'll be slightly more generous with the range to make it easier to hover + const range = diagnostic.range; - getChildren(element?: ErrorHint): Thenable { - if (element) { - return Promise.resolve(element.children); - } else { - return Promise.resolve([...this.buildErrorData, ...this.openocdErrorData]); - } - } + // Expand the range slightly to make it easier to hover + const lineText = document.lineAt(range.start.line).text; + const expandedRange = new vscode.Range( + new vscode.Position(range.start.line, 0), + new vscode.Position(range.end.line, lineText.length) + ); - clearErrorHints(clearOpenOCD: boolean = false) { - this.buildErrorData = []; - if (clearOpenOCD) { - this.openocdErrorData = []; - } - this._onDidChangeTreeData.fire(); // Notify the view to refresh - } + // Check if position is within the expanded range + if (expandedRange.contains(position)) { + // Get hint object for this error message + const hintInfo = this.hintProvider.getHintForError(diagnostic.message); - /** - * Shows an OpenOCD error hint directly without searching in the hints.yml file - * @param errorMsg The error message - * @param hintMsg The hint message - * @param reference Optional URL reference - * @returns true if the hint was displayed, false otherwise - */ - public async showOpenOCDErrorHint( - errorMsg: string, - hintMsg: string, - reference?: string - ): Promise { - try { - this.openocdErrorData = []; - - // Create error and hint nodes - const error = new ErrorHint(errorMsg, "error"); - const hint = new ErrorHint(hintMsg, "hint", reference); - - // Add hint as child of error - error.addChild(hint); + if (hintInfo && hintInfo.hint) { + let hoverMessage = `**ESP-IDF Hint**: ${hintInfo.hint}`; - // If there's a reference, add it as a child of the hint - if (reference) { - const refItem = new ErrorHint(reference, "reference"); - hint.addChild(refItem); + // Add reference link if available + if (hintInfo.ref) { + hoverMessage += `\n\n[Reference Documentation](${hintInfo.ref})`; + } + // We found a hint, return it with markdown formatting + return new vscode.Hover(new vscode.MarkdownString(`${hoverMessage}`)); + } } - - // Add to the data array - this.openocdErrorData.push(error); - - // Notify that the tree data has changed - this._onDidChangeTreeData.fire(); - - return true; - } catch (error) { - Logger.errorNotify( - `Error showing OpenOCD error hint: ${error.message}`, - error, - "ErrorHintProvider showOpenOCDErrorHint" - ); - return false; } + + // No matching diagnostics found at this position + return null; } } @@ -449,61 +548,3 @@ async function getOpenOcdHintsYmlPath( return null; } } - -export class HintHoverProvider implements vscode.HoverProvider { - constructor(private hintProvider: ErrorHintProvider) {} - - provideHover( - document: vscode.TextDocument, - position: vscode.Position, - token: vscode.CancellationToken - ): vscode.ProviderResult { - // Get all diagnostics for this document - const diagnostics = vscode.languages - .getDiagnostics(document.uri) - .filter( - (diagnostic) => - diagnostic.source === "esp-idf" && - diagnostic.severity === vscode.DiagnosticSeverity.Error - ); - - // No ESP-IDF diagnostics found for this document - if (!diagnostics.length) { - return null; - } - - // Find diagnostics that contain the hover position - for (const diagnostic of diagnostics) { - // Check if position is within the diagnostic range - // We'll be slightly more generous with the range to make it easier to hover - const range = diagnostic.range; - - // Expand the range slightly to make it easier to hover - const lineText = document.lineAt(range.start.line).text; - const expandedRange = new vscode.Range( - new vscode.Position(range.start.line, 0), - new vscode.Position(range.end.line, lineText.length) - ); - - // Check if position is within the expanded range - if (expandedRange.contains(position)) { - // Get hint object for this error message - const hintInfo = this.hintProvider.getHintForError(diagnostic.message); - - if (hintInfo && hintInfo.hint) { - let hoverMessage = `**ESP-IDF Hint**: ${hintInfo.hint}`; - - // Add reference link if available - if (hintInfo.ref) { - hoverMessage += `\n\n[Reference Documentation](${hintInfo.ref})`; - } - // We found a hint, return it with markdown formatting - return new vscode.Hover(new vscode.MarkdownString(`${hoverMessage}`)); - } - } - } - - // No matching diagnostics found at this position - return null; - } -} diff --git a/src/extension.ts b/src/extension.ts index edcaad42d..e134e2d52 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -158,7 +158,7 @@ import { checkDebugAdapterRequirements } from "./espIdf/debugAdapter/checkPyReqs import { CDTDebugConfigurationProvider } from "./cdtDebugAdapter/debugConfProvider"; import { CDTDebugAdapterDescriptorFactory } from "./cdtDebugAdapter/server"; import { IdfReconfigureTask } from "./espIdf/reconfigure/task"; -import { ErrorHintProvider, HintHoverProvider } from "./espIdf/hints/index"; +import { ErrorHintProvider, ErrorHintTreeItem, HintHoverProvider } from "./espIdf/hints/index"; import { installWebsocketClient } from "./espIdf/monitor/checkWebsocketClient"; import { TroubleshootingPanel } from "./support/troubleshootPanel"; import { @@ -3686,18 +3686,51 @@ export async function activate(context: vscode.ExtensionContext) { } // Hints Viewer const treeDataProvider = new ErrorHintProvider(context); - vscode.window.registerTreeDataProvider("errorHints", treeDataProvider); - + + // Create and register the tree view with collapse all button + const treeView = vscode.window.createTreeView("errorHints", { + treeDataProvider: treeDataProvider, + showCollapseAll: true + }); + + // Set a title for the tree view + treeView.title = "Error Hints"; + + // Add the tree view to disposables + context.subscriptions.push(treeView); + + // Register commands for clearing error hints + vscode.commands.registerCommand("espIdf.errorHints.clearAll", () => { + treeDataProvider.clearErrorHints(true); // Clear both build and OpenOCD errors + }) + + vscode.commands.registerCommand("espIdf.errorHints.clearBuildErrors", () => { + treeDataProvider.clearErrorHints(false); // Clear only build errors + }) + + vscode.commands.registerCommand("espIdf.errorHints.clearOpenOCDErrors", () => { + treeDataProvider.clearOpenOCDErrorsOnly(); // Clear only OpenOCD errors + }) + + // Initialize OpenOCD error monitoring const openOCDErrorMonitor = OpenOCDErrorMonitor.init(treeDataProvider, workspaceRoot); await openOCDErrorMonitor.initialize(); - + + // Register disposal of the monitor + context.subscriptions.push({ + dispose: () => { + openOCDErrorMonitor.dispose(); + } + }); + + // Register command to manually search for errors vscode.commands.registerCommand("espIdf.searchError", async () => { const errorMsg = await vscode.window.showInputBox({ placeHolder: "Enter the error message", }); if (errorMsg) { treeDataProvider.searchError(errorMsg, workspaceRoot); - await vscode.commands.executeCommand("errorHints.focus"); + await vscode.commands.executeCommand("espIdf.errorHints.focus"); } }); @@ -3715,9 +3748,9 @@ export async function activate(context: vscode.ExtensionContext) { }); }); - // Clear existing error hints if no ESP-IDF diagnostics + // Only clear build errors if no ESP-IDF diagnostics if (espIdfDiagnostics.length === 0) { - treeDataProvider.clearErrorHints(false); + treeDataProvider.clearErrorHints(false); // Don't clear OpenOCD errors return; } @@ -3727,22 +3760,14 @@ export async function activate(context: vscode.ExtensionContext) { // TODO: Create a variable in globalstate to save configuration if focus should be enabled/disabled when diagnostics update if (foundHint) { - await vscode.commands.executeCommand("errorHints.focus"); + await vscode.commands.executeCommand("espIdf.errorHints.focus"); } }; - context.subscriptions.push({ - dispose: () => { - openOCDErrorMonitor.dispose(); - } - }); - // Attach a listener to the diagnostics collection - context.subscriptions.push( vscode.languages.onDidChangeDiagnostics((_event) => { processEspIdfDiagnostics(); }) - ); // Register the HintHoverProvider context.subscriptions.push( @@ -3972,7 +3997,7 @@ function registerTreeProvidersForIDFExplorer(context: vscode.ExtensionContext) { commandTreeDataProvider.registerDataProviderForTree("idfCommands"), rainMakerTreeDataProvider.registerDataProviderForTree("espRainmaker"), eFuseExplorer.registerDataProviderForTree("espEFuseExplorer"), - partitionTableTreeDataProvider.registerDataProvider("idfPartitionExplorer") + partitionTableTreeDataProvider.registerDataProvider("idfPartitionExplorer"), ); } From db7b98e359fe991612906168a3246592d7ea149d Mon Sep 17 00:00:00 2001 From: radurentea Date: Fri, 7 Mar 2025 16:39:40 +0200 Subject: [PATCH 09/16] Add openocd version validation for hints --- src/espIdf/hints/openocdhint.ts | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/src/espIdf/hints/openocdhint.ts b/src/espIdf/hints/openocdhint.ts index a0b5eb491..ba5bed903 100644 --- a/src/espIdf/hints/openocdhint.ts +++ b/src/espIdf/hints/openocdhint.ts @@ -18,7 +18,7 @@ import { readFile, pathExists } from "fs-extra"; import * as path from "path"; import * as idfConf from "../../idfConfiguration"; import { Logger } from "../../logger/logger"; -import { OutputChannel } from "../../logger/outputChannel"; +import { PreCheck } from "../../utils"; import { OpenOCDManager } from "../openOcd/openOcdManager"; import { ErrorHintProvider } from "./index"; @@ -67,13 +67,31 @@ export class OpenOCDErrorMonitor { public async initialize(): Promise { try { + // Check OpenOCD version first + const openOCDManager = OpenOCDManager.init(); + const version = await openOCDManager.version(); + + if (!version) { + Logger.info( + "Could not determine OpenOCD version. Hints file won't be loaded." + ); + return null; + } + + // Skip initialization if openOCD version is not supporting hints + const minRequiredVersion = "v0.12.0-esp32-20250226"; + if (!version || !PreCheck.openOCDVersionValidator(minRequiredVersion, version)) { + Logger.info(`OpenOCD version ${version} doesn't support hints. Minimum required: ${minRequiredVersion}`); + return; + } + // Load OpenOCD hints data const toolsPath = idfConf.readParameter( "idf.toolsPath", this.workspaceRoot ) as string; - const openOcdHintsPath = await this.getOpenOcdHintsYmlPath(toolsPath); + const openOcdHintsPath = await this.getOpenOcdHintsYmlPath(toolsPath, version); if (openOcdHintsPath && (await pathExists(openOcdHintsPath))) { try { @@ -114,17 +132,8 @@ export class OpenOCDErrorMonitor { } } - private async getOpenOcdHintsYmlPath(toolsPath: string): Promise { + private async getOpenOcdHintsYmlPath(toolsPath: string, version: string): Promise { try { - const openOCDManager = OpenOCDManager.init(); - const version = await openOCDManager.version(); - - if (!version) { - Logger.info( - "Could not determine OpenOCD version. Hints file won't be loaded." - ); - return null; - } const hintsPath = path.join( toolsPath, From 6f800abcbbcc02ca774ab57c31430d73163e60b7 Mon Sep 17 00:00:00 2001 From: radurentea Date: Tue, 11 Mar 2025 11:47:33 +0200 Subject: [PATCH 10/16] Fix regex for build errors - fix errors related to errorHints view --- package.json | 12 ++++++------ src/espIdf/hints/index.ts | 27 ++++++++++++++++++++------- src/espIdf/hints/openocdhint.ts | 2 +- src/extension.ts | 6 +++--- 4 files changed, 30 insertions(+), 17 deletions(-) diff --git a/package.json b/package.json index d10f543a1..91a8ea427 100644 --- a/package.json +++ b/package.json @@ -316,9 +316,9 @@ "views": { "espIdfHints": [ { - "id": "errorHints", + "id": "idfErrorHints", "name": "Error Hints", - "title": "Error Hints ($errorHints.count$)" + "title": "Error Hints ($idfErrorHints.count$)" } ], "debug": [ @@ -402,13 +402,13 @@ "view/title": [ { "command": "espIdf.errorHints.clearAll", - "when": "view == errorHints", + "when": "view == idfErrorHints", "group": "navigation" }, { "command": "espIdf.searchError", "group": "navigation", - "when": "view == errorHints" + "when": "view == idfErrorHints" }, { "command": "espIdf.partition.table.refresh", @@ -453,11 +453,11 @@ "view/item/context": [ { "command": "espIdf.errorHints.clearBuildErrors", - "when": "view == errorHints && viewItem == buildError" + "when": "view == idfErrorHints && viewItem == buildError" }, { "command": "espIdf.errorHints.clearOpenOCDErrors", - "when": "view == errorHints && viewItem == openocdError" + "when": "view == idfErrorHints && viewItem == openocdError" }, { "command": "esp.rainmaker.backend.logout", diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index a58f8fcc0..b485f4853 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -257,16 +257,27 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { let meaningfulHintFound = false; + let errorFullMessage = ""; for (const hintPair of reHintsPairArray) { const match = new RegExp(hintPair.re, "i").exec(errorMsg); - const regexParts = Array.from(hintPair.re.matchAll(/\(([^)]+)\)/g)) - .map((m) => m[1].split("|")) - .flat() - .map((part) => part.toLowerCase()); - + const regexParts = []; + // Extract meaningful parts from regex by breaking at top-level pipes + // outside of parentheses or use a proper regex parser + const mainPattern = hintPair.re.replace(/^.*?'(.*)'.*$/, '$1'); // Extract pattern between quotes if present + if (mainPattern) { + // Split by top-level pipes, preserving grouped expressions + const parts = mainPattern.split(/\|(?![^(]*\))/); + for (const part of parts) { + // Clean up any remaining parentheses for direct string matching + const cleaned = part.replace(/[()]/g, ''); + if (cleaned.length > 3) { // Avoid very short fragments + regexParts.push(cleaned.toLowerCase()); + } + } + } if ( - match || + match || hintPair.re.toLowerCase().includes(errorMsg) || regexParts.some((part) => errorMsg.toLowerCase().includes(part)) ) { let finalHint = hintPair.hint; @@ -292,7 +303,9 @@ export class ErrorHintProvider implements vscode.TreeDataProvider Date: Tue, 11 Mar 2025 12:17:20 +0200 Subject: [PATCH 11/16] Fix search for openOCD hints --- src/espIdf/hints/index.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index b485f4853..47c882a81 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -523,8 +523,8 @@ async function getOpenOcdHintsYmlPath( workspace: vscode.Uri ): Promise { try { - const espIdfPath = idfConf.readParameter( - "idf.espIdfPath", + const idfToolsPath = idfConf.readParameter( + "idf.toolsPath", workspace ) as string; @@ -539,7 +539,7 @@ async function getOpenOcdHintsYmlPath( } const hintsPath = path.join( - espIdfPath, + idfToolsPath, "tools", "openocd-esp32", version, From 3f79a8baf1d589f83c9627526a09fd642debbff5 Mon Sep 17 00:00:00 2001 From: radurentea Date: Wed, 12 Mar 2025 12:54:09 +0200 Subject: [PATCH 12/16] Fix parsing inside loadHints --- src/espIdf/hints/index.ts | 160 ++++++++++++++++++++++++++++++++++---- 1 file changed, 143 insertions(+), 17 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index 47c882a81..4afc67dbc 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -21,11 +21,15 @@ import * as vscode from "vscode"; import * as path from "path"; import { OpenOCDManager } from "../openOcd/openOcdManager"; -class ReHintPair { - re: string; - hint: string; - match_to_output: boolean; - ref?: string; +/** + * Class representing a pair of regular expression and its corresponding hint. + * Used to match error messages and provide helpful guidance. + */ +class ReHintPair { + re: string; // Regular expression to match error messages + hint: string; // Hint text to show when the regex matches + match_to_output: boolean; // Whether to insert matched groups into the hint + ref?: string; // Link to documentation for openOCD hints constructor( re: string, @@ -193,7 +197,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider vars[Number(idx)] || "" ); + + return result; + } + + /** + * Expands regex patterns with alternatives into separate entries + * This is critical for match_to_output: true cases where the match needs + * to be inserted into the hint + * + * @param re - Regular expression string with possible alternatives in parentheses + * @param hint - Hint template with {} placeholders for matches + * @returns Array of {re, hint} pairs with alternatives expanded + * + * Example: + * expandAlternatives( + * "fatal error: (spiram.h|esp_spiram.h): No such file or directory", + * "{} was removed. Include esp_psram.h instead." + * ) + * + * Results in: + * [ + * { + * re: "fatal error: spiram.h: No such file or directory", + * hint: "spiram.h was removed. Include esp_psram.h instead." + * }, + * { + * re: "fatal error: esp_spiram.h: No such file or directory", + * hint: "esp_spiram.h was removed. Include esp_psram.h instead." + * } + * ] + */ + private expandAlternatives(re: string, hint: string): Array<{re: string, hint: string}> { + const result: Array<{re: string, hint: string}> = []; + + // Find all alternatives in parentheses with pipe characters + // Example: in "(spiram.h|esp_spiram.h)" we'll find alternatives "spiram.h" and "esp_spiram.h" + const alternativeMatches = re.match(/\(([^()]*\|[^()]*)\)/g); + + if (!alternativeMatches) { + // No alternatives found, return the original as-is + return [{re, hint}]; + } + + // Process each alternative group + for (const match of alternativeMatches) { + const alternatives = match.slice(1, -1).split('|'); // Remove parens and split by pipe + + if (result.length === 0) { + // Initial population of result + for (const alt of alternatives) { + const newRe = re.replace(match, alt); + // For each alternative, create a new hint with the alternative inserted + const newHint = hint.replace(/\{\}/, alt); + result.push({re: newRe, hint: newHint}); + } + } else { + // For subsequent alternative groups, multiply the existing results + const currentResults = [...result]; + result.length = 0; + + for (const existingEntry of currentResults) { + for (const alt of alternatives) { + const newRe = existingEntry.re.replace(match, alt); + // For each alternative, create a new hint with the alternative inserted + const newHint = existingEntry.hint.replace(/\{\}/, alt); + result.push({re: newRe, hint: newHint}); + } + } + } + } + return result; } } From b4d5294f58a613dbe5efd16746399d2de1f373c4 Mon Sep 17 00:00:00 2001 From: radurentea Date: Wed, 12 Mar 2025 13:03:20 +0200 Subject: [PATCH 13/16] Fix hints on hover - change === to includes - remove checking for openOCD hints, hints from openocd will not be present in text editor --- src/espIdf/hints/index.ts | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index 4afc67dbc..c9a885f58 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -355,20 +355,10 @@ export class ErrorHintProvider implements vscode.TreeDataProvider 0) { - const hintItem = errorHint.children[0]; - return { - hint: hintItem.label.replace(/^💡 /, ''), - ref: hintItem.reference - }; - } - } - - // Check in OpenOCD errors - for (const errorHint of this.openocdErrorData) { - if (errorHint.label === errorMsg && errorHint.children.length > 0) { + if (errorHint.label.toLowerCase().includes(errorMsg.toLowerCase()) && errorHint.children.length > 0) { const hintItem = errorHint.children[0]; return { hint: hintItem.label.replace(/^💡 /, ''), From b22d6c6551fd5b57d62100f0b649ae4ab385c57e Mon Sep 17 00:00:00 2001 From: radurentea Date: Fri, 14 Mar 2025 11:16:16 +0200 Subject: [PATCH 14/16] Replace autofocus for build hints to notification --- src/extension.ts | 30 ++++++++++++++++++++++++++---- src/logger/utils.ts | 31 +++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 4 deletions(-) diff --git a/src/extension.ts b/src/extension.ts index d374f6498..4f991ace2 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -41,7 +41,7 @@ import { ExamplesPlanel } from "./examples/ExamplesPanel"; import * as idfConf from "./idfConfiguration"; import { Logger } from "./logger/logger"; import { OutputChannel } from "./logger/outputChannel"; -import { showInfoNotificationWithAction } from "./logger/utils"; +import { showInfoNotificationWithAction, showInfoNotificationWithMultipleActions, showQuickPickWithCustomActions } from "./logger/utils"; import * as utils from "./utils"; import { PreCheck } from "./utils"; import { @@ -276,6 +276,9 @@ export async function activate(context: vscode.ExtensionContext) { vscode.commands.registerCommand(name, telemetryCallback) ); }; + // Store display hints notification (until VS Code is closed) + context.workspaceState.update('idf.showHintsNotification', true); + // init rainmaker cache store ESP.Rainmaker.store = RainmakerStore.init(context); @@ -3758,9 +3761,28 @@ export async function activate(context: vscode.ExtensionContext) { const errorMsg = espIdfDiagnostics[0].diagnostic.message; const foundHint = await treeDataProvider.searchError(errorMsg, workspaceRoot); - // TODO: Create a variable in globalstate to save configuration if focus should be enabled/disabled when diagnostics update - if (foundHint) { - await vscode.commands.executeCommand("idfErrorHints.focus"); + const showHintsNotification = context.workspaceState.get('idf.showHintsNotification') + if (foundHint && showHintsNotification) { + const actions = [ + { + label: vscode.l10n.t("💡 Show Hints"), + action: () => vscode.commands.executeCommand("idfErrorHints.focus") + }, + { + label: vscode.l10n.t("Mute for this session"), + action: () => { + context.workspaceState.update('idf.showHintsNotification', false); + vscode.window.showInformationMessage( + vscode.l10n.t("Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel") + ); + } + } + ]; + + await showInfoNotificationWithMultipleActions( + vscode.l10n.t(`Possible hint found for the error: {0}`, errorMsg), + actions + ); } }; diff --git a/src/logger/utils.ts b/src/logger/utils.ts index 2d4576381..d01f02f77 100644 --- a/src/logger/utils.ts +++ b/src/logger/utils.ts @@ -23,6 +23,37 @@ export async function showInfoNotificationWithAction( } } +/** +* Shows an information notification with multiple buttons that execute custom actions when clicked. +* @param {string} infoMessage - The information message to display. +* @param {Array<{label: string, action: NotificationAction}>} actions - An array of objects, each containing a button label and an action to perform when clicked. +* @returns {Promise} - A promise that resolves when the notification is shown and handled. +* @example +* showInfoNotificationWithMultipleActions( +* "Solution available", +* [ +* { label: "View Solution", action: () => openSolution() }, +* { label: "Mute for this session", action: () => disableNotifications() } +* ] +* ); +*/ +export async function showInfoNotificationWithMultipleActions( + infoMessage: string, + actions: { label: string; action: NotificationAction }[] +): Promise { + const selectedOption = await vscode.window.showInformationMessage( + infoMessage, + ...actions.map(action => action.label) + ); + + if (selectedOption) { + const selectedAction = actions.find(action => action.label === selectedOption); + if (selectedAction) { + await Promise.resolve(selectedAction.action()); + } + } +} + /** * Shows an error notification with a button that opens a link when clicked. * @param {string} infoMessage - The waning message to display. From e30cad7623ccb89b0fd7ab7c8724414cf06d1ab3 Mon Sep 17 00:00:00 2001 From: radurentea Date: Fri, 14 Mar 2025 11:16:49 +0200 Subject: [PATCH 15/16] Fix linting --- src/extension.ts | 110 +++++++++++++++++++++++++++----------------- src/logger/utils.ts | 34 +++++++------- 2 files changed, 87 insertions(+), 57 deletions(-) diff --git a/src/extension.ts b/src/extension.ts index 4f991ace2..bad9d559a 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -41,7 +41,11 @@ import { ExamplesPlanel } from "./examples/ExamplesPanel"; import * as idfConf from "./idfConfiguration"; import { Logger } from "./logger/logger"; import { OutputChannel } from "./logger/outputChannel"; -import { showInfoNotificationWithAction, showInfoNotificationWithMultipleActions, showQuickPickWithCustomActions } from "./logger/utils"; +import { + showInfoNotificationWithAction, + showInfoNotificationWithMultipleActions, + showQuickPickWithCustomActions, +} from "./logger/utils"; import * as utils from "./utils"; import { PreCheck } from "./utils"; import { @@ -158,7 +162,11 @@ import { checkDebugAdapterRequirements } from "./espIdf/debugAdapter/checkPyReqs import { CDTDebugConfigurationProvider } from "./cdtDebugAdapter/debugConfProvider"; import { CDTDebugAdapterDescriptorFactory } from "./cdtDebugAdapter/server"; import { IdfReconfigureTask } from "./espIdf/reconfigure/task"; -import { ErrorHintProvider, ErrorHintTreeItem, HintHoverProvider } from "./espIdf/hints/index"; +import { + ErrorHintProvider, + ErrorHintTreeItem, + HintHoverProvider, +} from "./espIdf/hints/index"; import { installWebsocketClient } from "./espIdf/monitor/checkWebsocketClient"; import { TroubleshootingPanel } from "./support/troubleshootPanel"; import { @@ -277,7 +285,7 @@ export async function activate(context: vscode.ExtensionContext) { ); }; // Store display hints notification (until VS Code is closed) - context.workspaceState.update('idf.showHintsNotification', true); + context.workspaceState.update("idf.showHintsNotification", true); // init rainmaker cache store ESP.Rainmaker.store = RainmakerStore.init(context); @@ -3689,43 +3697,49 @@ export async function activate(context: vscode.ExtensionContext) { } // Hints Viewer const treeDataProvider = new ErrorHintProvider(context); - + // Create and register the tree view with collapse all button const treeView = vscode.window.createTreeView("idfErrorHints", { treeDataProvider: treeDataProvider, - showCollapseAll: true + showCollapseAll: true, }); - + // Set a title for the tree view treeView.title = "Error Hints"; - + // Add the tree view to disposables context.subscriptions.push(treeView); - + // Register commands for clearing error hints - vscode.commands.registerCommand("espIdf.errorHints.clearAll", () => { - treeDataProvider.clearErrorHints(true); // Clear both build and OpenOCD errors - }) - - vscode.commands.registerCommand("espIdf.errorHints.clearBuildErrors", () => { - treeDataProvider.clearErrorHints(false); // Clear only build errors - }) - - vscode.commands.registerCommand("espIdf.errorHints.clearOpenOCDErrors", () => { + vscode.commands.registerCommand("espIdf.errorHints.clearAll", () => { + treeDataProvider.clearErrorHints(true); // Clear both build and OpenOCD errors + }); + + vscode.commands.registerCommand("espIdf.errorHints.clearBuildErrors", () => { + treeDataProvider.clearErrorHints(false); // Clear only build errors + }); + + vscode.commands.registerCommand( + "espIdf.errorHints.clearOpenOCDErrors", + () => { treeDataProvider.clearOpenOCDErrorsOnly(); // Clear only OpenOCD errors - }) - + } + ); + // Initialize OpenOCD error monitoring - const openOCDErrorMonitor = OpenOCDErrorMonitor.init(treeDataProvider, workspaceRoot); + const openOCDErrorMonitor = OpenOCDErrorMonitor.init( + treeDataProvider, + workspaceRoot + ); await openOCDErrorMonitor.initialize(); - + // Register disposal of the monitor context.subscriptions.push({ dispose: () => { openOCDErrorMonitor.dispose(); - } + }, }); - + // Register command to manually search for errors vscode.commands.registerCommand("espIdf.searchError", async () => { const errorMsg = await vscode.window.showInputBox({ @@ -3740,45 +3754,59 @@ export async function activate(context: vscode.ExtensionContext) { // Function to process all ESP-IDF diagnostics from the problems panel const processEspIdfDiagnostics = async () => { // Get all diagnostics from all files that have source "esp-idf" - const espIdfDiagnostics: Array<{ uri: vscode.Uri; diagnostic: vscode.Diagnostic }> = []; - + const espIdfDiagnostics: Array<{ + uri: vscode.Uri; + diagnostic: vscode.Diagnostic; + }> = []; + // Collect all diagnostics from all files that have source "esp-idf" vscode.languages.getDiagnostics().forEach(([uri, diagnostics]) => { diagnostics - .filter(d => d.source === "esp-idf" && d.severity === vscode.DiagnosticSeverity.Error) - .forEach(diagnostic => { + .filter( + (d) => + d.source === "esp-idf" && + d.severity === vscode.DiagnosticSeverity.Error + ) + .forEach((diagnostic) => { espIdfDiagnostics.push({ uri, diagnostic }); }); }); - + // Only clear build errors if no ESP-IDF diagnostics if (espIdfDiagnostics.length === 0) { treeDataProvider.clearErrorHints(false); // Don't clear OpenOCD errors return; } - + // Process the first error if available const errorMsg = espIdfDiagnostics[0].diagnostic.message; - const foundHint = await treeDataProvider.searchError(errorMsg, workspaceRoot); + const foundHint = await treeDataProvider.searchError( + errorMsg, + workspaceRoot + ); - const showHintsNotification = context.workspaceState.get('idf.showHintsNotification') + const showHintsNotification = context.workspaceState.get( + "idf.showHintsNotification" + ); if (foundHint && showHintsNotification) { const actions = [ { label: vscode.l10n.t("💡 Show Hints"), - action: () => vscode.commands.executeCommand("idfErrorHints.focus") + action: () => vscode.commands.executeCommand("idfErrorHints.focus"), }, { label: vscode.l10n.t("Mute for this session"), action: () => { - context.workspaceState.update('idf.showHintsNotification', false); + context.workspaceState.update("idf.showHintsNotification", false); vscode.window.showInformationMessage( - vscode.l10n.t("Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel") + vscode.l10n.t( + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel" + ) ); - } - } + }, + }, ]; - + await showInfoNotificationWithMultipleActions( vscode.l10n.t(`Possible hint found for the error: {0}`, errorMsg), actions @@ -3787,9 +3815,9 @@ export async function activate(context: vscode.ExtensionContext) { }; // Attach a listener to the diagnostics collection - vscode.languages.onDidChangeDiagnostics((_event) => { - processEspIdfDiagnostics(); - }) + vscode.languages.onDidChangeDiagnostics((_event) => { + processEspIdfDiagnostics(); + }); // Register the HintHoverProvider context.subscriptions.push( @@ -4019,7 +4047,7 @@ function registerTreeProvidersForIDFExplorer(context: vscode.ExtensionContext) { commandTreeDataProvider.registerDataProviderForTree("idfCommands"), rainMakerTreeDataProvider.registerDataProviderForTree("espRainmaker"), eFuseExplorer.registerDataProviderForTree("espEFuseExplorer"), - partitionTableTreeDataProvider.registerDataProvider("idfPartitionExplorer"), + partitionTableTreeDataProvider.registerDataProvider("idfPartitionExplorer") ); } diff --git a/src/logger/utils.ts b/src/logger/utils.ts index d01f02f77..216520cde 100644 --- a/src/logger/utils.ts +++ b/src/logger/utils.ts @@ -24,30 +24,32 @@ export async function showInfoNotificationWithAction( } /** -* Shows an information notification with multiple buttons that execute custom actions when clicked. -* @param {string} infoMessage - The information message to display. -* @param {Array<{label: string, action: NotificationAction}>} actions - An array of objects, each containing a button label and an action to perform when clicked. -* @returns {Promise} - A promise that resolves when the notification is shown and handled. -* @example -* showInfoNotificationWithMultipleActions( -* "Solution available", -* [ -* { label: "View Solution", action: () => openSolution() }, -* { label: "Mute for this session", action: () => disableNotifications() } -* ] -* ); -*/ + * Shows an information notification with multiple buttons that execute custom actions when clicked. + * @param {string} infoMessage - The information message to display. + * @param {Array<{label: string, action: NotificationAction}>} actions - An array of objects, each containing a button label and an action to perform when clicked. + * @returns {Promise} - A promise that resolves when the notification is shown and handled. + * @example + * showInfoNotificationWithMultipleActions( + * "Solution available", + * [ + * { label: "View Solution", action: () => openSolution() }, + * { label: "Mute for this session", action: () => disableNotifications() } + * ] + * ); + */ export async function showInfoNotificationWithMultipleActions( infoMessage: string, actions: { label: string; action: NotificationAction }[] ): Promise { const selectedOption = await vscode.window.showInformationMessage( infoMessage, - ...actions.map(action => action.label) + ...actions.map((action) => action.label) ); - + if (selectedOption) { - const selectedAction = actions.find(action => action.label === selectedOption); + const selectedAction = actions.find( + (action) => action.label === selectedOption + ); if (selectedAction) { await Promise.resolve(selectedAction.action()); } From 645e7a0cbf0dc5963031f3b19a422d07d85c9a64 Mon Sep 17 00:00:00 2001 From: radurentea Date: Fri, 14 Mar 2025 12:45:50 +0200 Subject: [PATCH 16/16] Add translations --- l10n/bundle.l10n.es.json | 6 +++++- l10n/bundle.l10n.pt.json | 6 +++++- l10n/bundle.l10n.ru.json | 6 +++++- l10n/bundle.l10n.zh-CN.json | 6 +++++- src/extension.ts | 1 - 5 files changed, 20 insertions(+), 5 deletions(-) diff --git a/l10n/bundle.l10n.es.json b/l10n/bundle.l10n.es.json index d36df9a5f..bc781450a 100644 --- a/l10n/bundle.l10n.es.json +++ b/l10n/bundle.l10n.es.json @@ -209,5 +209,9 @@ "Failed to remove settings: {0}": "Error al eliminar las configuraciones: {0}", "Error: {0}": "Error: {0}", "🔗 Reference Documentation": "🔗 Documentación de Referencia", - "Open {0}": "Abrir {0}" + "Open {0}": "Abrir {0}", + "💡 Show Hints": "💡 Mostrar Pistas", + "Mute for this session": "Silenciar para esta sesión", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Notificaciones de pistas silenciadas para esta sesión. Todavía puede acceder a las pistas manualmente en el panel inferior de ESP-IDF", + "Possible hint found for the error: {0}": "Posible pista encontrada para el error: {0}" } diff --git a/l10n/bundle.l10n.pt.json b/l10n/bundle.l10n.pt.json index a2fb088c4..327c903c2 100644 --- a/l10n/bundle.l10n.pt.json +++ b/l10n/bundle.l10n.pt.json @@ -209,5 +209,9 @@ "Failed to remove settings: {0}": "Falha ao remover configurações: {0}", "Error: {0}": "Erro: {0}", "🔗 Reference Documentation": "🔗Documentação de Referência", - "Open {0}": "Abrir {0}" + "Open {0}": "Abrir {0}", + "💡 Show Hints": "💡 Mostrar Dicas", + "Mute for this session": "Silenciar para esta sessão", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Notificações de dicas silenciadas para esta sessão. Você ainda pode acessar dicas manualmente no painel inferior do ESP-IDF", + "Possible hint found for the error: {0}": "Possível dica encontrada para o erro: {0}" } diff --git a/l10n/bundle.l10n.ru.json b/l10n/bundle.l10n.ru.json index f8b85d6b3..dfc27e485 100644 --- a/l10n/bundle.l10n.ru.json +++ b/l10n/bundle.l10n.ru.json @@ -209,5 +209,9 @@ "Failed to remove settings: {0}": "Не удалось удалить настройки: {0}", "Error: {0}": "Ошибка: {0}", "🔗 Reference Documentation": "🔗 Справочная Документация", - "Open {0}": "Открыть {0}" + "Open {0}": "Открыть {0}", + "💡 Show Hints": "💡 Показать Подсказки", + "Mute for this session": "Отключить звук для этой сессии", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Уведомления с подсказками отключены для этой сессии. Вы все еще можете получить доступ к подсказкам вручную в нижней панели ESP-IDF", + "Possible hint found for the error: {0}": "Возможная подсказка найдена для ошибки: {0}" } diff --git a/l10n/bundle.l10n.zh-CN.json b/l10n/bundle.l10n.zh-CN.json index 2725d3d7d..5722b99f8 100644 --- a/l10n/bundle.l10n.zh-CN.json +++ b/l10n/bundle.l10n.zh-CN.json @@ -209,5 +209,9 @@ "Failed to remove settings: {0}": "删除设置失败：{0}", "Error: {0}": "错误：{0}", "🔗 Reference Documentation": "🔗 参考文档", - "Open {0}": "打开 {0}" + "Open {0}": "打开 {0}", + "💡 Show Hints": "💡 显示提示", + "Mute for this session": "为本次会话静音", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "本次会话的提示通知已静音。您仍然可以在 ESP-IDF 底部面板中手动访问提示", + "Possible hint found for the error: {0}": "已找到可能的错误提示：{0}" } diff --git a/src/extension.ts b/src/extension.ts index bad9d559a..67596f8e1 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -44,7 +44,6 @@ import { OutputChannel } from "./logger/outputChannel"; import { showInfoNotificationWithAction, showInfoNotificationWithMultipleActions, - showQuickPickWithCustomActions, } from "./logger/utils"; import * as utils from "./utils"; import { PreCheck } from "./utils";