Merge pull request #9400 from microsoft/main

Author: Colengms

Extension/CHANGELOG.md

@@ -1,5 +1,12 @@
 # C/C++ for Visual Studio Code Change Log
 
+## Version 1.10.4: June 3, 2022
+### Bug Fixes
+* Fix formatting issue with vcFormat when using multi-byte UTF-8 sequences. [#9297](https://github.com/microsoft/vscode-cpptools/issues/9297)
+* Add support for "user" level and "workspace" level debug configurations. [#9319](https://github.com/microsoft/vscode-cpptools/issues/9319)
+* Fix code analysis with g++ 12 system headers. [#9347](https://github.com/microsoft/vscode-cpptools/issues/9347)
+* Fix crash on macOS <= 10.14, due to missing symbol. [#9387](https://github.com/microsoft/vscode-cpptools/issues/9387)
+
 ## Version 1.10.3: May 23, 2022
 ### New Feature
 * Add code actions to apply clang-tidy fixes. [#8476](https://github.com/microsoft/vscode-cpptools/issues/8476)

Extension/package.json

@@ -2,7 +2,7 @@
   "name": "cpptools",
   "displayName": "C/C++",
   "description": "C/C++ IntelliSense, debugging, and code browsing.",
-  "version": "1.10.3-main",
+  "version": "1.10.4-main",
   "publisher": "ms-vscode",
   "icon": "LanguageCCPP_color_128x.png",
   "readme": "README.md",

Extension/src/Debugger/configurationProvider.ts

@@ -5,20 +5,66 @@
 
 import * as os from 'os';
 import * as nls from 'vscode-nls';
+import * as vscode from 'vscode';
 import { configPrefix } from '../LanguageServer/extension';
 
 nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
 const localize: nls.LocalizeFunc = nls.loadMessageBundle();
 
+export function isDebugLaunchStr(str: string): boolean {
+    return str.startsWith("(gdb) ") || str.startsWith("(lldb) ") || str.startsWith("(Windows) ");
+}
+
+export interface ConfigMenu extends vscode.QuickPickItem {
+    configuration: CppDebugConfiguration;
+}
+
 export enum DebuggerType {
     cppvsdbg = "cppvsdbg",
     cppdbg = "cppdbg",
     all = "all"
 }
 
 export enum DebuggerEvent {
-    debugPanel = "debugPanel",
-    launchPlayButton = "launchPlayButton"
+    debugPanel = "debugPanel",  // F5 or "Run and Debug" Panel
+    playButton = "playButton",   // "Run and Debug" play button
+    addConfigGear = "AddConfigGear"
+}
+
+export enum TaskStatus {
+    recentlyUsed = "Recently Used Task", // A configured task that has been used recently.
+
+    configured = "Configured Task", // The tasks that are configured in tasks.json file.
+    detected = "Detected Task"      // The tasks that are available based on detected compilers.
+}
+
+export enum ConfigSource {
+    singleFile = "singleFile",              // a debug config defined for a single mode file
+    workspaceFolder = "workspaceFolder",    // a debug config defined in launch.json
+    workspace = "workspace",                // a debug config defined in workspace level
+    global = "global",                      // a debug config defined in user level
+    unknown = "unknown"
+}
+
+export enum ConfigMode {
+    launchConfig = "launchConfig",
+    noLaunchConfig = "noLaunchConfig",
+    unknown = "unknown"
+}
+
+export enum DebugType {
+    debug = "debug",
+    run = "run"
+}
+
+export interface CppDebugConfiguration extends vscode.DebugConfiguration {
+    detail?: string;
+    taskStatus?: TaskStatus;
+    isDefault?: boolean; // The debug configuration is considered as default, if the prelaunch task is set as default.
+    configSource?: ConfigSource;
+    debuggerEvent?: DebuggerEvent;
+    debugType?: DebugType;
+    existing?: boolean;
 }
 
 export interface IConfigurationSnippet {

Extension/src/Debugger/configurations.ts

@@ -226,26 +226,32 @@ export class CppBuildTaskProvider implements TaskProvider {
         return buildTasksJson.filter((task: CppBuildTask) => task !== null);
     }
 
-    public async writeDefaultBuildTask(taskLabel: string): Promise<void> {
-        return this.writeBuildTask(taskLabel, true);
+    public async writeDefaultBuildTask(taskLabel: string, workspaceFolder?: WorkspaceFolder): Promise<void> {
+        return this.writeBuildTask(taskLabel, workspaceFolder, true);
     }
 
-    public async writeBuildTask(taskLabel: string, setAsDefault: boolean = false): Promise<void> {
-        const rawTasksJson: any = await this.getRawTasksJson();
+    public async isExistingTask(taskLabel: string, workspaceFolder?: WorkspaceFolder): Promise<boolean> {
+        const rawTasksJson: any = await this.getRawTasksJson(workspaceFolder);
+        if (!rawTasksJson.tasks) {
+            return false;
+        }
+        // Check if the task exists in the user's task.json.
+        return rawTasksJson.tasks.find((task: any) => task.label && task.label === taskLabel);
+    }
+
+    public async writeBuildTask(taskLabel: string, workspaceFolder?: WorkspaceFolder, setAsDefault: boolean = false): Promise<void> {
+        const rawTasksJson: any = await this.getRawTasksJson(workspaceFolder);
         if (!rawTasksJson.tasks) {
             rawTasksJson.tasks = new Array();
         }
         // Check if the task exists in the user's task.json.
-        let selectedTask: any;
-        selectedTask = rawTasksJson.tasks.find((task: any) => task.label && task.label === taskLabel);
-        if (selectedTask) {
+        if (rawTasksJson.tasks.find((task: any) => task.label && task.label === taskLabel)) {
             return;
         }
 
         // Create the task which should be created based on the selected "debug configuration".
         const buildTasks: CppBuildTask[] = await this.getTasks(true);
-        const normalizedLabel: string = (taskLabel.indexOf("ver(") !== -1) ? taskLabel.slice(0, taskLabel.indexOf("ver(")).trim() : taskLabel;
-        selectedTask = buildTasks.find(task => task.name === normalizedLabel);
+        const selectedTask: any = buildTasks.find(task => task.name === taskLabel);
         console.assert(selectedTask);
         if (!selectedTask) {
             throw new Error("Failed to get selectedTask in checkBuildTaskExists()");
@@ -313,12 +319,12 @@ export class CppBuildTaskProvider implements TaskProvider {
         }
     }
 
-    private getTasksJsonPath(): string | undefined {
-        return util.getJsonPath("tasks.json");
+    private getTasksJsonPath(workspaceFolder?: WorkspaceFolder): string | undefined {
+        return util.getJsonPath("tasks.json", workspaceFolder);
     }
 
-    public getRawTasksJson(): Promise<any> {
-        const path: string | undefined = this.getTasksJsonPath();
+    public getRawTasksJson(workspaceFolder?: WorkspaceFolder): Promise<any> {
+        const path: string | undefined = this.getTasksJsonPath(workspaceFolder);
         return util.getRawJson(path);
     }
 

Extension/src/LanguageServer/cppBuildTaskProvider.ts

@@ -905,19 +905,32 @@ function handleMacCrashFileRead(err: NodeJS.ErrnoException | undefined | null, d
         binaryVersion = binaryVersionMatches && binaryVersionMatches.length > 1 ? binaryVersionMatches[1] : "";
     }
 
+    // Extract any message indicating missing dynamically loaded symbols.
+    let dynamicLoadError: string = "";
+    const dynamicLoadErrorStart: string = "Dyld Error Message:";
+    const startDynamicLoadError: number = data.indexOf(dynamicLoadErrorStart);
+    if (startDynamicLoadError >= 0) {
+        // Scan until the next blank line.
+        const dynamicLoadErrorEnd: string = "\n\n";
+        const endDynamicLoadError: number = data.indexOf(dynamicLoadErrorEnd, startDynamicLoadError);
+        if (endDynamicLoadError >= 0) {
+            dynamicLoadError = data.substring(startDynamicLoadError, endDynamicLoadError) + "\n\n";
+        }
+    }
+
     // Extract the crashing thread's call stack.
     const crashStart: string = " Crashed:";
     let startCrash: number = data.indexOf(crashStart);
     if (startCrash < 0) {
-        return logMacCrashTelemetry("No crash start");
+        return logMacCrashTelemetry(dynamicLoadError + "No crash start");
     }
     startCrash += crashStart.length + 1; // Skip past crashStart.
     let endCrash: number = data.indexOf("Thread ", startCrash);
     if (endCrash < 0) {
         endCrash = data.length - 1; // Not expected, but just in case.
     }
     if (endCrash <= startCrash) {
-        return logMacCrashTelemetry("No crash end");
+        return logMacCrashTelemetry(dynamicLoadError + "No crash end");
     }
     data = data.substring(startCrash, endCrash);
 
@@ -926,7 +939,10 @@ function handleMacCrashFileRead(err: NodeJS.ErrnoException | undefined | null, d
     data = data.replace(/0x1........ \+ 0/g, "");
 
     // Get rid of the process names on each line and just add it to the start.
-    const processNames: string[] = ["cpptools-srv", "cpptools-wordexp", "cpptools" ];
+    const processNames: string[] = ["cpptools-srv", "cpptools-wordexp", "cpptools",
+        // Since only crash logs that start with "cpptools" are reported, the cases below would only occur
+        // if the crash were to happen before the new process had fully started and renamed itself.
+        "clang-tidy", "clang-format", "clang", "gcc" ];
     let processNameFound: boolean = false;
     for (const processName of processNames) {
         if (data.includes(processName)) {
@@ -938,7 +954,8 @@ function handleMacCrashFileRead(err: NodeJS.ErrnoException | undefined | null, d
     }
     if (!processNameFound) {
         // Not expected, but just in case a new binary gets added.
-        data = `cpptools???\t${binaryVersion}\n${data}`;
+        // Warning: Don't use ??? because that is checked below.
+        data = `cpptools??\t${binaryVersion}\n${data}`;
     }
 
     // Remove runtime lines because they can be different on different machines.
@@ -953,6 +970,9 @@ function handleMacCrashFileRead(err: NodeJS.ErrnoException | undefined | null, d
     });
     data = data.trimRight();
 
+    // Prepend the dynamic load error.
+    data = dynamicLoadError + data;
+
     if (data.length > 8192) { // The API has an 8k limit.
         data = data.substring(0, 8189) + "...";
     }

Extension/src/LanguageServer/extension.ts

@@ -109,12 +109,12 @@ export function getPackageJsonPath(): string {
     return getExtensionFilePath("package.json");
 }
 
-export function getJsonPath(jsonFilaName: string): string | undefined {
+export function getJsonPath(jsonFilaName: string, workspaceFolder?: vscode.WorkspaceFolder): string | undefined {
     const editor: vscode.TextEditor | undefined = vscode.window.activeTextEditor;
     if (!editor) {
         return undefined;
     }
-    const folder: vscode.WorkspaceFolder | undefined = vscode.workspace.getWorkspaceFolder(editor.document.uri);
+    const folder: vscode.WorkspaceFolder | undefined = workspaceFolder ? workspaceFolder : vscode.workspace.getWorkspaceFolder(editor.document.uri);
     if (!folder) {
         return undefined;
     }