Merge for 1.23.1

Extension/CHANGELOG.md

@@ -1,5 +1,19 @@
 # C/C++ for Visual Studio Code Changelog
 
+### Version 1.23.1: November 6, 2024
+### Bug Fixes
+* A potential fix for a crash during process shutdown (in `uv_run`). [#12668](https://github.com/microsoft/vscode-cpptools/issues/12668)
+* Fix a performance issue where some LSP requests would delay other LSP requests. [#12905](https://github.com/microsoft/vscode-cpptools/issues/12905)
+* A potential fix for a crash in cpptools (in `report_intellisense_results`).
+* Fix a random deadlock in `handle_edits`.
+* Other internal fixes.
+
+## Version 1.22.11: November 5, 2024
+### Bug Fixes
+* Fix system includes incorrectly being treated as non-system includes when specified with `-I`. [#12842](https://github.com/microsoft/vscode-cpptools/issues/12842)
+* Fix inactive region ranges when multi-byte UTF-8 characters are used. [#12879](https://github.com/microsoft/vscode-cpptools/issues/12879)
+* Fix formatting with `.editorconfig` files. [#12921](https://github.com/microsoft/vscode-cpptools/issues/12921)
+
 ## Version 1.23.0: October 29, 2024
 ### Enhancements
 * Update to clang-format and clang-tidy 19.1.2. [#12824](https://github.com/microsoft/vscode-cpptools/issues/12824)

Extension/package.json

@@ -2,7 +2,7 @@
     "name": "cpptools",
     "displayName": "C/C++",
     "description": "C/C++ IntelliSense, debugging, and code browsing.",
-    "version": "1.23.0-main",
+    "version": "1.23.1-main",
     "publisher": "ms-vscode",
     "icon": "LanguageCCPP_color_128x.png",
     "readme": "README.md",
@@ -6511,7 +6511,7 @@
         "translations-generate": "set NODE_OPTIONS=--no-experimental-fetch && gulp translations-generate",
         "translations-import": "gulp translations-import",
         "import-edge-strings": "ts-node -T ./.scripts/import_edge_strings.ts",
-        "prep:dts": "yarn verify dts --quiet || (npx vscode-dts dev && npx vscode-dts main)",
+        "prep:dts": "yarn verify dts --quiet || (npx @vscode/dts dev && npx @vscode/dts main)",
         "build": "yarn prep:dts && echo [Building TypeScript code] && tsc --build tsconfig.json"
     },
     "devDependencies": {

Extension/src/LanguageServer/configurations.ts

@@ -1948,7 +1948,7 @@ export class CppProperties {
             compilerPath = checkPathExists.path;
         }
         if (!compilerPathExists) {
-            compilerMessage = localize('cannot.find2', "Cannot find \"{0}\".", compilerPath);
+            compilerMessage = localize('cannot.find', "Cannot find: {0}", compilerPath);
             newSquiggleMetrics.PathNonExistent++;
         }
         if (compilerMessage) {
@@ -1975,7 +1975,7 @@ export class CppProperties {
             dotConfigPath = checkPathExists.path;
         }
         if (!dotConfigPathExists) {
-            dotConfigMessage = localize('cannot.find2', "Cannot find \"{0}\".", dotConfigPath);
+            dotConfigMessage = localize('cannot.find', "Cannot find: {0}", dotConfigPath);
             newSquiggleMetrics.PathNonExistent++;
         } else if (dotConfigPath && !util.checkFileExistsSync(dotConfigPath)) {
             dotConfigMessage = localize("path.is.not.a.file", "Path is not a file: {0}", dotConfigPath);
@@ -2083,7 +2083,7 @@ export class CppProperties {
                         } else {
                             badPath = `"${expandedPaths[0]}"`;
                         }
-                        message = localize('cannot.find2', "Cannot find {0}", badPath);
+                        message = localize('cannot.find', "Cannot find: {0}", badPath);
                         newSquiggleMetrics.PathNonExistent++;
                     } else {
                         // Check for file versus path mismatches.
@@ -2141,7 +2141,7 @@ export class CppProperties {
                         endOffset = curOffset + curMatch.length;
                         let message: string;
                         if (!pathExists) {
-                            message = localize('cannot.find2', "Cannot find \"{0}\".", expandedPaths[0]);
+                            message = localize('cannot.find', "Cannot find: {0}", expandedPaths[0]);
                             newSquiggleMetrics.PathNonExistent++;
                             const diagnostic: vscode.Diagnostic = new vscode.Diagnostic(
                                 new vscode.Range(document.positionAt(envTextStartOffSet + curOffset),

Extension/src/LanguageServer/editorConfig.ts

@@ -92,7 +92,17 @@ function parseEditorConfigContent(content: string): Record<string, any> {
             const [key, ...values] = line.split('=');
             if (key && values.length > 0) {
                 const trimmedKey = key.trim();
-                const value = values.join('=').trim();
+                let value: any = values.join('=').trim();
+
+                // Convert boolean-like and numeric values.
+                if (value.toLowerCase() === 'true') {
+                    value = true;
+                } else if (value.toLowerCase() === 'false') {
+                    value = false;
+                } else if (!isNaN(Number(value))) {
+                    value = Number(value);
+                }
+
                 if (currentSection) {
                     // Ensure the current section is initialized.
                     if (!config[currentSection]) {
@@ -114,7 +124,7 @@ function getEditorConfig(filePath: string): any {
     const rootDir: string = path.parse(currentDir).root;
 
     // Traverse from the file's directory to the root directory.
-    for (;;) {
+    for (; ;) {
         const editorConfigPath: string = path.join(currentDir, '.editorconfig');
         if (fs.existsSync(editorConfigPath)) {
             const configFileContent: string = fs.readFileSync(editorConfigPath, 'utf-8');
@@ -139,7 +149,7 @@ function getEditorConfig(filePath: string): any {
             });
 
             // Check if the current .editorconfig is the root.
-            if (configData['*']?.root?.toLowerCase() === 'true') {
+            if (configData['*']?.root) {
                 break; // Stop searching after processing the root = true file.
             }
         }

Extension/src/LanguageServer/lmTool.ts

@@ -51,6 +51,7 @@ export class CppConfigurationLanguageModelTool implements vscode.LanguageModelTo
     }
 
     private async getContext(token: vscode.CancellationToken): Promise<string> {
+        const telemetryProperties: Record<string, string> = {};
         try {
             const currentDoc = vscode.window.activeTextEditor?.document;
             if (!currentDoc || (!util.isCpp(currentDoc) && !util.isHeaderFile(currentDoc.uri))) {
@@ -62,28 +63,44 @@ export class CppConfigurationLanguageModelTool implements vscode.LanguageModelTo
                 return 'No configuration information is available for the active document.';
             }
 
-            telemetry.logLanguageModelToolEvent(
-                'cpp',
-                {
-                    "language": chatContext.language,
-                    "compiler": chatContext.compiler,
-                    "standardVersion": chatContext.standardVersion,
-                    "targetPlatform": chatContext.targetPlatform,
-                    "targetArchitecture": chatContext.targetArchitecture
-                });
-
             for (const key in knownValues) {
                 const knownKey = key as keyof ChatContextResult;
                 if (knownValues[knownKey] && chatContext[knownKey]) {
-                    chatContext[knownKey] = knownValues[knownKey][chatContext[knownKey]] || chatContext[knownKey];
+                    // Clear the value if it's not in the known values.
+                    chatContext[knownKey] = knownValues[knownKey][chatContext[knownKey]] || "";
                 }
             }
 
-            return `The user is working on a ${chatContext.language} project. The project uses language version ${chatContext.standardVersion}, compiles using the ${chatContext.compiler} compiler, targets the ${chatContext.targetPlatform} platform, and targets the ${chatContext.targetArchitecture} architecture.`;
+            let contextString = "";
+            if (chatContext.language) {
+                contextString += `The user is working on a ${chatContext.language} project. `;
+                telemetryProperties["language"] = chatContext.language;
+            }
+            if (chatContext.standardVersion) {
+                contextString += `The project uses language version ${chatContext.standardVersion}. `;
+                telemetryProperties["standardVersion"] = chatContext.standardVersion;
+            }
+            if (chatContext.compiler) {
+                contextString += `The project compiles using the ${chatContext.compiler} compiler. `;
+                telemetryProperties["compiler"] = chatContext.compiler;
+            }
+            if (chatContext.targetPlatform) {
+                contextString += `The project targets the ${chatContext.targetPlatform} platform. `;
+                telemetryProperties["targetPlatform"] = chatContext.targetPlatform;
+            }
+            if (chatContext.targetArchitecture) {
+                contextString += `The project targets the ${chatContext.targetArchitecture} architecture. `;
+                telemetryProperties["targetArchitecture"] = chatContext.targetArchitecture;
+            }
+
+            return contextString;
         }
         catch {
             await this.reportError();
+            telemetryProperties["error"] = "true";
             return "";
+        } finally {
+            telemetry.logLanguageModelToolEvent('cpp', telemetryProperties);
         }
     }
 

Extension/src/LanguageServer/protocolFilter.ts

@@ -8,6 +8,7 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import { Middleware } from 'vscode-languageclient';
 import * as util from '../common';
+import { logAndReturn } from '../Utility/Async/returns';
 import { Client } from './client';
 import { clients } from './extension';
 import { shouldChangeFromCToCpp } from './utils';
@@ -18,14 +19,8 @@ export const ServerCancelled: number = -32802;
 let anyFileOpened: boolean = false;
 
 export function createProtocolFilter(): Middleware {
-    // Disabling lint for invoke handlers
-    const invoke1 = (a: any, next: (a: any) => any): any => clients.ActiveClient.enqueue(() => next(a));
-    const invoke2 = (a: any, b: any, next: (a: any, b: any) => any): any => clients.ActiveClient.enqueue(() => next(a, b));
-    const invoke3 = (a: any, b: any, c: any, next: (a: any, b: any, c: any) => any): any => clients.ActiveClient.enqueue(() => next(a, b, c));
-    const invoke4 = (a: any, b: any, c: any, d: any, next: (a: any, b: any, c: any, d: any) => any): any => clients.ActiveClient.enqueue(() => next(a, b, c, d));
-
     return {
-        didOpen: async (document, sendMessage) => clients.ActiveClient.enqueue(async () => {
+        didOpen: async (document, sendMessage) => {
             if (!util.isCpp(document)) {
                 return;
             }
@@ -41,62 +36,41 @@ export function createProtocolFilter(): Middleware {
                         const mappingString: string = baseFileName + "@" + document.fileName;
                         client.addFileAssociations(mappingString, "cpp");
                         client.sendDidChangeSettings();
-                        document = await vscode.languages.setTextDocumentLanguage(document, "cpp");
+                        // This will cause the file to be closed and reopened.
+                        void vscode.languages.setTextDocumentLanguage(document, "cpp");
+                        return;
                     }
                     // client.takeOwnership() will call client.TrackedDocuments.add() again, but that's ok. It's a Set.
                     client.onDidOpenTextDocument(document);
                     client.takeOwnership(document);
-                    await sendMessage(document);
-
-                    // For a file already open when we activate, sometimes we don't get any notifications about visible
-                    // or active text editors, visible ranges, or text selection. As a workaround, we trigger
-                    // onDidChangeVisibleTextEditors here, only for the first file opened.
-                    if (!anyFileOpened) {
-                        anyFileOpened = true;
-                        const cppEditors: vscode.TextEditor[] = vscode.window.visibleTextEditors.filter(e => util.isCpp(e.document));
-                        await client.onDidChangeVisibleTextEditors(cppEditors);
-                    }
+                    void sendMessage(document).then(() => {
+                        // For a file already open when we activate, sometimes we don't get any notifications about visible
+                        // or active text editors, visible ranges, or text selection. As a workaround, we trigger
+                        // onDidChangeVisibleTextEditors here, only for the first file opened.
+                        if (!anyFileOpened) {
+                            anyFileOpened = true;
+                            const cppEditors: vscode.TextEditor[] = vscode.window.visibleTextEditors.filter(e => util.isCpp(e.document));
+                            client.onDidChangeVisibleTextEditors(cppEditors).catch(logAndReturn.undefined);
+                        }
+                    });
                 }
             }
-        }),
-        didChange: invoke1,
-        willSave: invoke1,
+        },
         willSaveWaitUntil: async (event, sendMessage) => {
-            // await clients.ActiveClient.ready;
-            // Don't use awaitUntilLanguageClientReady.
-            // Otherwise, the message can be delayed too long.
             const me: Client = clients.getClientFor(event.document.uri);
             if (me.TrackedDocuments.has(event.document.uri.toString())) {
                 return sendMessage(event);
             }
             return [];
         },
-        didSave: invoke1,
-        didClose: async (document, sendMessage) => clients.ActiveClient.enqueue(async () => {
+        didClose: async (document, sendMessage) => {
             const me: Client = clients.getClientFor(document.uri);
             const uriString: string = document.uri.toString();
             if (me.TrackedDocuments.has(uriString)) {
                 me.onDidCloseTextDocument(document);
                 me.TrackedDocuments.delete(uriString);
-                await sendMessage(document);
-            }
-        }),
-        provideCompletionItem: invoke4,
-        resolveCompletionItem: invoke2,
-        provideHover: async (document, position, token, next: (document: any, position: any, token: any) => any) => clients.ActiveClient.enqueue(async () => {
-            const me: Client = clients.getClientFor(document.uri);
-            if (me.TrackedDocuments.has(document.uri.toString())) {
-                return next(document, position, token);
+                void sendMessage(document);
             }
-            return null;
-        }),
-        provideSignatureHelp: invoke4,
-        provideDefinition: invoke3,
-        provideReferences: invoke4,
-        provideDocumentHighlights: invoke3,
-        provideDeclaration: invoke3,
-        workspace: {
-            didChangeConfiguration: invoke1
         }
     };
 }