don't use falsy comparisons when resolving default settings. (#2592)

Author: shankaryoga21

Extension/src/LanguageServer/configurations.ts

@@ -215,39 +215,43 @@ export class CppProperties {
         if (this.configurationIncomplete && this.defaultIncludes && this.defaultFrameworks && this.vcpkgPathReady) {
             let configuration: Configuration = this.CurrentConfiguration;
             let settings: CppSettings = new CppSettings(this.rootUri);
+            let isUnset: (input: any) => boolean = (input: any) => {
+                // default values for "default" config settings is null.
+                return input === null;
+            };
 
             // Anything that has a vscode setting for it will be resolved in updateServerOnFolderSettingsChange.
             // So if a property is currently unset, but has a vscode setting, don't set it yet, otherwise the linkage
             // to the setting will be lost if this configuration is saved into a c_cpp_properties.json file.
 
             // Only add settings from the default compiler if user hasn't explicitly set the corresponding VS Code setting.
 
-            if (!settings.defaultIncludePath) {
+            if (isUnset(settings.defaultIncludePath)) {
                 // We don't add system includes to the includePath anymore. The language server has this information.
                 let abTestSettings: ABTestSettings = getABTestSettings();
                 let rootFolder: string = abTestSettings.UseRecursiveIncludes ? "${workspaceFolder}/**" : "${workspaceFolder}";
                 configuration.includePath = [rootFolder].concat(this.vcpkgIncludes);
             }
             // browse.path is not set by default anymore. When it is not set, the includePath will be used instead.
-            if (!settings.defaultDefines) {
+            if (isUnset(settings.defaultDefines)) {
                 configuration.defines = (process.platform === 'win32') ? ["_DEBUG", "UNICODE", "_UNICODE"] : [];
             }
-            if (!settings.defaultMacFrameworkPath && process.platform === 'darwin') {
+            if (isUnset(settings.defaultMacFrameworkPath) && process.platform === 'darwin') {
                 configuration.macFrameworkPath = this.defaultFrameworks;
             }
-            if (!settings.defaultWindowsSdkVersion && this.defaultWindowsSdkVersion && process.platform === 'win32') {
+            if (isUnset(settings.defaultWindowsSdkVersion) && this.defaultWindowsSdkVersion && process.platform === 'win32') {
                 configuration.windowsSdkVersion = this.defaultWindowsSdkVersion;
             }
-            if (!settings.defaultCompilerPath && this.defaultCompilerPath) {
+            if (isUnset(settings.defaultCompilerPath) && this.defaultCompilerPath) {
                 configuration.compilerPath = this.defaultCompilerPath;
             }
-            if (!settings.defaultCStandard && this.defaultCStandard) {
+            if (isUnset(settings.defaultCStandard) && this.defaultCStandard) {
                 configuration.cStandard = this.defaultCStandard;
             }
-            if (!settings.defaultCppStandard && this.defaultCppStandard) {
+            if (isUnset(settings.defaultCppStandard) && this.defaultCppStandard) {
                 configuration.cppStandard = this.defaultCppStandard;
             }
-            if (!settings.defaultIntelliSenseMode) {
+            if (isUnset(settings.defaultIntelliSenseMode)) {
                 configuration.intelliSenseMode = this.defaultIntelliSenseMode;
             }
             this.configurationIncomplete = false;
@@ -431,11 +435,11 @@ export class CppProperties {
     private updateConfiguration(property: string, defaultValue: string, env: Environment): string;
     private updateConfiguration(property: string | boolean, defaultValue: boolean, env: Environment): boolean;
     private updateConfiguration(property, defaultValue, env): any {
-        if (typeof property === "string" || typeof defaultValue === "string") {
+        if (util.isString(property) || util.isString(defaultValue)) {
             return this.resolveVariables(property, defaultValue, env);
-        } else if (typeof property === "boolean" || typeof defaultValue === "boolean") {
+        } else if (util.isBoolean(property) || util.isBoolean(defaultValue)) {
             return this.resolveVariables(property, defaultValue, env);
-        } else if (property instanceof Array || defaultValue instanceof Array) {
+        } else if (util.isArrayOfString(property) || util.isArrayOfString(defaultValue)) {
             if (property) {
                 return this.resolveAndSplit(property, defaultValue, env);
             } else if (property === undefined && defaultValue) {

Extension/src/common.ts

@@ -183,12 +183,20 @@ export function isNumber(input: any): input is number {
     return typeof(input) === "number";
 }
 
+export function isBoolean(input: any): input is boolean {
+    return typeof(input) === "boolean";
+}
+
+export function isArray(input: any): input is any[] {
+    return input instanceof Array;
+}
+
 export function isOptionalString(input: any): input is string|undefined {
     return input === undefined || isString(input);
 }
 
 export function isArrayOfString(input: any): input is string[] {
-    return (input instanceof Array) && input.every(item => isString(item));
+    return isArray(input) && input.every(item => isString(item));
 }
 
 export function isOptionalArrayOfString(input: any): input is string[]|undefined {