Avoid overloading dimInactiveRegions setting. (requires native side changes)

Author: Colengms

Extension/package.json

@@ -1075,7 +1075,7 @@
                     "C_Cpp.autoFoldInactiveRegions": {
                         "type": "boolean",
                         "default": false,
-                        "description": "%c_cpp.configuration.autoFoldInactiveRegions.description%",
+                        "markdownDescription": "%c_cpp.configuration.autoFoldInactiveRegions.description%",
                         "scope": "resource"
                     },
                     "C_Cpp.inactiveRegionOpacity": {

Extension/package.nls.json

@@ -488,7 +488,7 @@
     "c_cpp.configuration.autocomplete.disabled.description": "Uses the word-based completion provided by Visual Studio Code.",
     "c_cpp.configuration.errorSquiggles.description": "Controls whether suspected compile errors detected by the IntelliSense engine will be reported back to the editor. It also controls whether code analysis warnings are reported if includes can't be found. This setting is ignored by the Tag Parser engine.",
     "c_cpp.configuration.dimInactiveRegions.description": "Controls whether inactive preprocessor blocks are colored differently than active code. This setting has no effect if IntelliSense is disabled or if using the Default High Contrast theme.",
-    "c_cpp.configuration.autoFoldInactiveRegions.description": "Controls whether inactive preprocessor blocks are automatically folded when a file is opened. This setting requires IntelliSense and code folding to be enabled.",
+    "c_cpp.configuration.autoFoldInactiveRegions.description": "Controls whether inactive preprocessor blocks are automatically folded when a file is opened. This setting only applies when `#C_Cpp.intelliSenseEngine#` is `default` and `#C_Cpp.codeFolding#` is `enabled`.",
     "c_cpp.configuration.inactiveRegionOpacity.markdownDescription": {
         "message": "Controls the opacity of inactive preprocessor blocks. Scales between `0.1` and `1.0`. This setting only applies when inactive region dimming is enabled.",
         "comment": [

Extension/src/LanguageServer/client.ts

@@ -887,6 +887,7 @@ export class DefaultClient implements Client {
     private inactiveRegionsDecorations = new Map<string, DecorationRangesPair>();
     private inactiveRegions = new InactiveRegionStore();
     private pendingInactiveRegionFoldingOperations = new WeakMap<vscode.TextEditor, InactiveRegionFoldingOperation>();
+    private inactiveRegionReportingEnabled: boolean;
     private settingsTracker: SettingsTracker;
     private loggingLevel: number = 1;
     private configurationProvider?: string;
@@ -1328,6 +1329,7 @@ export class DefaultClient implements Client {
         }
 
         const rootUri: vscode.Uri | undefined = this.RootUri;
+        this.inactiveRegionReportingEnabled = new CppSettings(rootUri).inactiveRegionReportingEnabled;
         this.settingsTracker = new SettingsTracker(rootUri);
 
         try {
@@ -1477,8 +1479,8 @@ export class DefaultClient implements Client {
             intelliSenseCachePath: util.resolveCachePath(settings.intelliSenseCachePath, this.AdditionalEnvironment),
             intelliSenseCacheSize: settings.intelliSenseCacheSize,
             intelliSenseMemoryLimit: settings.intelliSenseMemoryLimit,
-            // Native uses this flag to decide whether to report inactive ranges.
-            dimInactiveRegions: settings.dimInactiveRegions || settings.autoFoldInactiveRegions || settings.codeFolding,
+            dimInactiveRegions: settings.dimInactiveRegions,
+            codeFolding: settings.codeFolding,
             suggestSnippets: settings.suggestSnippets,
             legacyCompilerArgsBehavior: settings.legacyCompilerArgsBehavior,
             defaultSystemIncludePath: settings.defaultSystemIncludePath,
@@ -1851,6 +1853,11 @@ export class DefaultClient implements Client {
         await this.ready;
 
         if (Object.keys(changedSettings).length > 0) {
+            const inactiveRegionReportingEnabled: boolean = new CppSettings(this.RootUri).inactiveRegionReportingEnabled;
+            if (inactiveRegionReportingEnabled !== this.inactiveRegionReportingEnabled) {
+                this.inactiveRegionReportingEnabled = inactiveRegionReportingEnabled;
+                this.inactiveRegions.clear();
+            }
             if (this === defaultClient) {
                 if (changedSettings.commentContinuationPatterns2 !== undefined) {
                     updateLanguageConfigurations();
@@ -3044,8 +3051,7 @@ export class DefaultClient implements Client {
         }
 
         const settings: CppSettings = new CppSettings(editor.document.uri);
-        const autoFold: boolean = settings.autoFoldInactiveRegions && settings.codeFolding
-            && !DefaultClient.autoFoldedEditors.has(editor);
+        const autoFold: boolean = settings.autoFoldInactiveRegions && !DefaultClient.autoFoldedEditors.has(editor);
         const pendingOperation: InactiveRegionFoldingOperation | undefined =
             this.pendingInactiveRegionFoldingOperations.get(editor);
         const operation: InactiveRegionFoldingOperation | undefined = pendingOperation ?? (autoFold ? 'fold' : undefined);
@@ -3065,6 +3071,7 @@ export class DefaultClient implements Client {
         }
 
         try {
+            await this.languageClient.refreshFoldingRanges(editor.document);
             await vscode.commands.executeCommand(`editor.${operation}`, {
                 selectionLines,
                 direction: 'down'

Extension/src/LanguageServer/inactiveRegions.ts

@@ -43,6 +43,10 @@ export class InactiveRegionStore {
         this.regionSets.forEach((regionSet, uri) => callback(regionSet.regions, uri));
     }
 
+    public clear(): void {
+        this.regionSets.clear();
+    }
+
     public delete(uri: string): void {
         this.regionSets.delete(uri);
     }

Extension/src/LanguageServer/settings.ts

@@ -49,6 +49,7 @@ export interface WorkspaceFolderSettingsParams {
     intelliSenseCacheSize: number;
     intelliSenseMemoryLimit: number;
     dimInactiveRegions: boolean;
+    codeFolding: boolean;
     suggestSnippets: boolean;
     legacyCompilerArgsBehavior: boolean;
     defaultSystemIncludePath: string[] | undefined;
@@ -377,7 +378,15 @@ export class CppSettings extends Settings {
     public get inactiveRegionOpacity(): number { return this.getAsNumber("inactiveRegionOpacity"); }
     public get inactiveRegionForegroundColor(): string | undefined { return changeBlankStringToUndefined(this.getAsStringOrUndefined("inactiveRegionForegroundColor")); }
     public get inactiveRegionBackgroundColor(): string | undefined { return changeBlankStringToUndefined(this.getAsStringOrUndefined("inactiveRegionBackgroundColor")); }
-    public get autoFoldInactiveRegions(): boolean { return this.getAsBoolean("autoFoldInactiveRegions"); }
+    public get autoFoldInactiveRegions(): boolean {
+        return this.getAsBoolean("autoFoldInactiveRegions")
+            && this.codeFolding
+            && this.intelliSenseEngine.toLowerCase() === "default";
+    }
+    public get inactiveRegionReportingEnabled(): boolean {
+        return this.dimInactiveRegions
+            || (this.codeFolding && this.intelliSenseEngine.toLowerCase() === "default");
+    }
     public get autocomplete(): string { return this.getAsString("autocomplete"); }
     public get autocompleteAddParentheses(): boolean { return this.getAsBoolean("autocompleteAddParentheses"); }
     public get loggingLevel(): string { return this.getAsString("loggingLevel"); }

Extension/test/unit/inactiveRegions.test.ts

@@ -60,6 +60,15 @@ suite("InactiveRegionStore", () => {
         assert.deepStrictEqual(entries, [[uri, [firstRegion, secondRegion]]]);
     });
 
+    test("clears all cached regions", () => {
+        const store: InactiveRegionStore = new InactiveRegionStore();
+        store.update(uri, [firstRegion], true, true);
+
+        store.clear();
+
+        assert.strictEqual(store.getComplete(uri), undefined);
+    });
+
     test("returns sorted unique start lines", () => {
         assert.deepStrictEqual(getInactiveRegionStartLines([secondRegion, firstRegion, secondRegion]), [2, 8]);
     });