pre-review

Author: bobbrow

Extension/c_cpp_properties.schema.json

@@ -18,10 +18,7 @@
                     "compilerPath": {
                         "markdownDescription": "Full path of the compiler being used, e.g. `/usr/bin/gcc`, to enable more accurate IntelliSense.",
                         "descriptionHint": "Markdown text between `` should not be translated or localized (they represent literal text) and the capitalization, spacing, and punctuation (including the ``) should not be altered.",
-                        "type": [
-                            "string",
-                            "null"
-                        ]
+                        "type": "string"
                     },
                     "compilerArgs": {
                         "markdownDescription": "Compiler arguments to modify the includes or defines used, e.g. `-nostdinc++`, `-m32`, etc. Arguments that take additional space-delimited arguments should be entered as separate arguments in the array, e.g. for `--sysroot <arg>` use `\"--sysroot\", \"<arg>\"`.",
@@ -312,4 +309,4 @@
         "version"
     ],
     "additionalProperties": false
-}
+}

Extension/src/LanguageServer/configurations.ts

@@ -1599,7 +1599,8 @@ export class CppProperties {
      * Get the compilerPath and args from a compilerPath string that has already passed through
      * `this.resolvePath`. If there are errors processing the path, those will also be returned.
      *
-     * @resolvedCompilerPath a compilerPath string that has already been resolved.
+     * @param resolvedCompilerPath a compilerPath string that has already been resolved.
+     * @param rootUri the workspace folder URI, if any.
      */
     public static validateCompilerPath(resolvedCompilerPath: string, rootUri?: vscode.Uri): util.CompilerPathAndArgs {
         if (!resolvedCompilerPath) {
@@ -1629,16 +1630,16 @@ export class CppProperties {
                         resolvedCompilerPath = pathLocation;
                         compilerPathAndArgs.compilerPath = pathLocation;
                     } else if (rootUri) {
-                        // Check again for a relative path.
-                        const relativePath: string = rootUri.fsPath + path.sep + resolvedCompilerPath;
-                        if (!fs.existsSync(relativePath)) {
-                            if (existsWithExeAdded(relativePath)) {
-                                resolvedCompilerPath = relativePath + ".exe";
+                        // Test if it was a relative path.
+                        const absolutePath: string = rootUri.fsPath + path.sep + resolvedCompilerPath;
+                        if (!fs.existsSync(absolutePath)) {
+                            if (existsWithExeAdded(absolutePath)) {
+                                resolvedCompilerPath = absolutePath + ".exe";
                             } else {
                                 pathExists = false;
                             }
                         } else {
-                            resolvedCompilerPath = relativePath;
+                            resolvedCompilerPath = absolutePath;
                         }
                     }
                 }

Extension/src/common.ts

@@ -1102,7 +1102,13 @@ export interface CompilerPathAndArgs {
 }
 
 /**
- * Parse the compiler path input into a compiler path and compiler args. If there are no args, the compilerPath will have been verified to exist.
+ * Parse the compiler path input into a compiler path and compiler args. If there are no args in the input string, this function will have
+ * verified that the compiler exists. (e.g. `compilerArgsFromCommandLineInPath` will be empty)
+ *
+ * @param useLegacyBehavior - If true, use the legacy behavior of separating the compilerPath from the args.
+ * @param inputCompilerPath - The compiler path input from the user.
+ * @param compilerArgs - The compiler args input from the user.
+ * @param cwd - The directory used to resolve relative paths.
  */
 export function extractCompilerPathAndArgs(useLegacyBehavior: boolean, inputCompilerPath?: string, compilerArgs?: string[], cwd?: string): CompilerPathAndArgs {
     let compilerPath: string | undefined = inputCompilerPath;
@@ -1137,7 +1143,7 @@ export function extractCompilerPathAndArgs(useLegacyBehavior: boolean, inputComp
             }
         } else {
             if (compilerPath.includes(' ')) {
-                // There is no leading quote, so we'll treat it as a command line.
+                // There is no leading quote, but there is a space so we'll treat it as a command line.
                 const potentialArgs: string[] = useLegacyBehavior ? legacyExtractArgs(compilerPath) : extractArgs(compilerPath);
                 compilerPath = trimLegacyQuotes(potentialArgs.shift());
                 compilerArgsFromCommandLineInPath = potentialArgs;