Initial implementation for supporting vcpkg (#1886)

* Initial implementation for supporting vcpkg

Author: Jim Griesmer

Extension/src/LanguageServer/configurations.ts

@@ -80,6 +80,8 @@ export class CppProperties {
     private defaultCppStandard: string = null;
     private defaultIncludes: string[] = null;
     private defaultFrameworks: string[] = null;
+    private vcpkgIncludes: string[] = [];
+    private vcpkgPathReady: boolean = false;
     private defaultIntelliSenseMode: string = null;
     private readonly configurationGlobPattern: string = "**/c_cpp_properties.json"; // TODO: probably should be a single file, not all files...
     private disposables: vscode.Disposable[] = [];
@@ -124,6 +126,8 @@ export class CppProperties {
             this.handleConfigurationChange();
         });
 
+        this.buildVcpkgIncludePath();
+
         this.disposables.push(vscode.Disposable.from(this.configurationsChanged, this.selectionChanged, this.compileCommandsChanged));
     }
 
@@ -184,8 +188,8 @@ export class CppProperties {
         this.configurationIncomplete = true;
     }
 
-    private applyDefaultIncludePathsAndFrameworks(): void {
-        if (this.configurationIncomplete && this.defaultIncludes && this.defaultFrameworks) {
+     private applyDefaultIncludePathsAndFrameworks(): void {
+        if (this.configurationIncomplete && this.defaultIncludes && this.defaultFrameworks && this.vcpkgPathReady) {
             let configuration: Configuration = this.configurationJson.configurations[this.CurrentConfiguration];
             let settings: CppSettings = new CppSettings(this.rootUri);
 
@@ -197,15 +201,15 @@ export class CppProperties {
 
             if (!settings.defaultIncludePath) {
                 // We don't add system includes to the includePath anymore. The language server has this information.
-                configuration.includePath = ["${workspaceFolder}"];
+                configuration.includePath = ["${workspaceFolder}"].concat(this.vcpkgIncludes);
+            }
+            if (!settings.defaultBrowsePath) {
+                // We don't add system includes to the includePath anymore. The language server has this information.
+                configuration.browse.path = ["${workspaceFolder}"].concat(this.vcpkgIncludes);
             }
             if (!settings.defaultDefines) {
                 configuration.defines = (process.platform === 'win32') ? ["_DEBUG", "UNICODE", "_UNICODE"] : [];
             }
-            if (!settings.defaultBrowsePath) {
-                // We don't add system includes to the browse.path anymore. The language server has this information.
-                configuration.browse.path = ["${workspaceFolder}"];
-            }
             if (!settings.defaultMacFrameworkPath && process.platform === 'darwin') {
                 configuration.macFrameworkPath = this.defaultFrameworks;
             }
@@ -225,6 +229,35 @@ export class CppProperties {
         }
     }
 
+    private async buildVcpkgIncludePath(): Promise<void> {
+        try {
+            // Check for vcpkg instance and include relevent paths if found.
+            if (await util.checkFileExists(util.getVcpkgPathDescriptorFile())) {
+                let vcpkgRoot: string = await util.readFileText(util.getVcpkgPathDescriptorFile());
+                let vcpkgInstallPath: string = path.join(vcpkgRoot.trim(), "/vcpkg/installed");
+                if (await util.checkDirectoryExists(vcpkgInstallPath)) {
+                    let list: string[] = await util.readDir(vcpkgInstallPath);
+                    // For every *directory* in the list (non-recursive)
+                    list.forEach((entry) => {
+                        if (entry !== "vcpkg") {
+                            let pathToCheck: string = path.join(vcpkgInstallPath, entry);
+                            if (fs.existsSync(pathToCheck)) {
+                                let p: string = path.join(pathToCheck, "include");
+                                if (fs.existsSync(p)) {
+                                    this.vcpkgIncludes.push(p);
+                                }
+                            }
+                        }
+                    });
+                }
+            }
+        } catch (error) {} finally {
+            this.vcpkgPathReady = true;
+            this.handleConfigurationChange();
+        }
+
+    }
+
     private getConfigIndexForPlatform(config: any): number {
         if (this.configurationJson.configurations.length > 3) {
             return this.configurationJson.configurations.length - 1; // Default to the last custom configuration.

Extension/src/common.ts

@@ -49,6 +49,14 @@ export function getPackageJsonPath(): string {
     return getExtensionFilePath("package.json");
 }
 
+export function getVcpkgPathDescriptorFile(): string {
+    if (process.platform === 'win32') {
+        return path.join(process.env.LOCALAPPDATA, "vcpkg/vcpkg.path.txt");
+    } else {
+        return path.join(process.env.HOME, ".vcpkg/vcpkg.path.txt");
+    }
+}
+
 // Extension is ready if install.lock exists and debugAdapters folder exist.
 export async function isExtensionReady(): Promise<boolean> {
     const doesInstallLockFileExist: boolean = await checkInstallLockFile();
@@ -266,6 +274,28 @@ export function checkFileExists(filePath: string): Promise<boolean> {
     });
 }
 
+/** Test whether a directory exists */
+export function checkDirectoryExists(dirPath: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+        fs.stat(dirPath, (err, stats) => {
+            if (stats && stats.isDirectory()) {
+                resolve(true);
+            } else {
+                resolve(false);
+            }
+        });
+    });
+}
+
+/** Read the files in a directory */
+export function readDir(dirPath: string): Promise<string[]> {
+    return new Promise((resolve) => {
+        fs.readdir(dirPath, (err, list) => {
+            resolve(list);
+            });
+        });
+}
+
 /** Test whether the lock file exists.*/
 export function checkInstallLockFile(): Promise<boolean> {
     return checkFileExists(getInstallLockPath());