Automatically fold inactive regions

Extension/package.json

@@ -1072,6 +1072,12 @@
                         "description": "%c_cpp.configuration.dimInactiveRegions.description%",
                         "scope": "resource"
                     },
+                    "C_Cpp.autoFoldInactiveRegions": {
+                        "type": "boolean",
+                        "default": false,
+                        "markdownDescription": "%c_cpp.configuration.autoFoldInactiveRegions.description%",
+                        "scope": "resource"
+                    },
                     "C_Cpp.inactiveRegionOpacity": {
                         "type": "number",
                         "default": 0.55,
@@ -3999,6 +4005,16 @@
                 "title": "%c_cpp.command.toggleDimInactiveRegions.title%",
                 "category": "C/C++"
             },
+            {
+                "command": "C_Cpp.FoldAllInactiveRegions",
+                "title": "%c_cpp.command.foldAllInactiveRegions.title%",
+                "category": "C/C++"
+            },
+            {
+                "command": "C_Cpp.UnfoldAllInactiveRegions",
+                "title": "%c_cpp.command.unfoldAllInactiveRegions.title%",
+                "category": "C/C++"
+            },
             {
                 "command": "C_Cpp.ResetDatabase",
                 "title": "%c_cpp.command.resetDatabase.title%",
@@ -6552,6 +6568,14 @@
                     "command": "C_Cpp.ToggleDimInactiveRegions",
                     "when": "config.C_Cpp.intelliSenseEngine =~ /^[dD]efault$/"
                 },
+                {
+                    "command": "C_Cpp.FoldAllInactiveRegions",
+                    "when": "editorLangId =~ /^(c|(cuda-)?cpp)$/ && config.C_Cpp.intelliSenseEngine =~ /^[dD]efault$/ && config.C_Cpp.codeFolding =~ /^[eE]nabled$/"
+                },
+                {
+                    "command": "C_Cpp.UnfoldAllInactiveRegions",
+                    "when": "editorLangId =~ /^(c|(cuda-)?cpp)$/ && config.C_Cpp.intelliSenseEngine =~ /^[dD]efault$/ && config.C_Cpp.codeFolding =~ /^[eE]nabled$/"
+                },
                 {
                     "command": "C_Cpp.ResetDatabase",
                     "when": "!(config.C_Cpp.intelliSenseEngine =~ /^[dD]isabled$/)"

Extension/package.nls.json

@@ -19,6 +19,8 @@
     "c_cpp.command.enableErrorSquiggles.title": "Enable Error Squiggles",
     "c_cpp.command.disableErrorSquiggles.title": "Disable Error Squiggles",
     "c_cpp.command.toggleDimInactiveRegions.title": "Toggle Inactive Region Colorization",
+    "c_cpp.command.foldAllInactiveRegions.title": "Fold All Inactive Regions",
+    "c_cpp.command.unfoldAllInactiveRegions.title": "Unfold All Inactive Regions",
     "c_cpp.command.resetDatabase.title": "Reset IntelliSense Database",
     "c_cpp.command.takeSurvey.title": "Take Survey",
     "c_cpp.command.restartIntelliSenseForFile.title": "Restart IntelliSense for Active File",
@@ -486,6 +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 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/extension.ts

@@ -396,6 +396,8 @@ export async function registerCommands(enabled: boolean): Promise<void> {
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.EnableErrorSquiggles', enabled ? onEnableSquiggles : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.DisableErrorSquiggles', enabled ? onDisableSquiggles : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.ToggleDimInactiveRegions', enabled ? onToggleDimInactiveRegions : onDisabledCommand));
+    commandDisposables.push(vscode.commands.registerCommand('C_Cpp.FoldAllInactiveRegions', enabled ? onFoldAllInactiveRegions : onDisabledCommand));
+    commandDisposables.push(vscode.commands.registerCommand('C_Cpp.UnfoldAllInactiveRegions', enabled ? onUnfoldAllInactiveRegions : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.PauseParsing', enabled ? onPauseParsing : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.ResumeParsing', enabled ? onResumeParsing : onDisabledCommand));
     commandDisposables.push(vscode.commands.registerCommand('C_Cpp.PauseCodeAnalysis', enabled ? onPauseCodeAnalysis : onDisabledCommand));
@@ -925,6 +927,16 @@ function onToggleDimInactiveRegions(): void {
     settings.update<boolean>("dimInactiveRegions", !settings.dimInactiveRegions);
 }
 
+function onFoldAllInactiveRegions(): Promise<void> {
+    const editor: vscode.TextEditor | undefined = vscode.window.activeTextEditor;
+    return editor ? clients.getClientFor(editor.document.uri).foldAllInactiveRegions() : Promise.resolve();
+}
+
+function onUnfoldAllInactiveRegions(): Promise<void> {
+    const editor: vscode.TextEditor | undefined = vscode.window.activeTextEditor;
+    return editor ? clients.getClientFor(editor.document.uri).unfoldAllInactiveRegions() : Promise.resolve();
+}
+
 function onPauseParsing(): void {
     void clients.ActiveClient.pauseParsing().catch(logAndReturn.undefined);
 }

Extension/src/LanguageServer/inactiveRegions.ts

@@ -0,0 +1,57 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export interface InactiveRegion {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+
+interface InactiveRegionSet {
+    regions: InactiveRegion[];
+    isComplete: boolean;
+}
+
+export class InactiveRegionStore {
+    private readonly regionSets = new Map<string, InactiveRegionSet>();
+
+    public update(uri: string, regions: InactiveRegion[], startNewSet: boolean, isComplete: boolean): void {
+        let regionSet: InactiveRegionSet | undefined = this.regionSets.get(uri);
+        if (startNewSet || regionSet === undefined) {
+            regionSet = {
+                regions: [],
+                isComplete: false
+            };
+            this.regionSets.set(uri, regionSet);
+        }
+
+        for (const region of regions) {
+            regionSet.regions.push(region);
+        }
+        regionSet.isComplete = isComplete;
+    }
+
+    public getComplete(uri: string): readonly InactiveRegion[] | undefined {
+        const regionSet: InactiveRegionSet | undefined = this.regionSets.get(uri);
+        return regionSet?.isComplete ? regionSet.regions : undefined;
+    }
+
+    public forEach(callback: (regions: readonly InactiveRegion[], uri: string) => void): void {
+        this.regionSets.forEach((regionSet, uri) => callback(regionSet.regions, uri));
+    }
+
+    public clear(): void {
+        this.regionSets.clear();
+    }
+
+    public delete(uri: string): void {
+        this.regionSets.delete(uri);
+    }
+}
+
+export function getInactiveRegionStartLines(regions: readonly InactiveRegion[]): number[] {
+    return [...new Set(regions.map(region => region.startLine))].sort((a, b) => a - b);
+}

Extension/src/LanguageServer/languageClient.ts

@@ -4,8 +4,8 @@
  * ------------------------------------------------------------------------------------------ */
 'use strict';
 
-import { Disposable } from 'vscode';
-import { CancellationToken, NotificationHandler, NotificationType, RequestType } from 'vscode-languageclient';
+import { Disposable, TextDocument } from 'vscode';
+import { CancellationToken, FoldingRangeRequest, NotificationHandler, NotificationType, RequestType } from 'vscode-languageclient';
 import * as rpc from 'vscode-languageclient/node';
 import { ManualSignal } from '../Utility/Async/manualSignal';
 
@@ -71,6 +71,11 @@ export class LanguageClient {
         return this.rpcClient.code2ProtocolConverter;
     }
 
+    public async refreshFoldingRanges(document: TextDocument): Promise<void> {
+        await this.ready;
+        this.rpcClient.getFeature(FoldingRangeRequest.method).getProvider(document)?.onDidChangeFoldingRange.fire();
+    }
+
     public async sendRequest<P, R, E>(type: RequestType<P, R, E>, params: P, token?: CancellationToken): Promise<R> {
         await this.ready;
         return this.rpcClient.sendRequest(type, params, token);

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,6 +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")
+            && 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/minBinaryVersion.json

@@ -1,3 +1,3 @@
 {
-    "minBinaryVersion": "1.33.0"
+    "minBinaryVersion": "1.35.3"
 }

Extension/test/scenarios/MultirootDeadlockTest/tests/inactiveFolding.test.ts

@@ -0,0 +1,139 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All Rights Reserved.
+ * See 'LICENSE' in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+/* eslint-disable @typescript-eslint/triple-slash-reference */
+/// <reference path="../../../../vscode.d.ts" />
+
+import * as assert from 'assert';
+import { suite } from 'mocha';
+import * as path from 'path';
+import * as sinon from 'sinon';
+import * as vscode from 'vscode';
+import * as api from 'vscode-cpptools';
+import * as apit from 'vscode-cpptools/out/testApi';
+import * as extension from '../../../../src/LanguageServer/extension';
+import * as testHelpers from '../../../common/testHelpers';
+
+suite("Inactive region folding in a multi-root workspace", function (): void {
+    let testHook: apit.CppToolsTestHook;
+    let firstWorkspaceFolder: vscode.WorkspaceFolder;
+    let workspaceFolder: vscode.WorkspaceFolder;
+
+    suiteSetup(async function (): Promise<void> {
+        await testHelpers.activateCppExtension();
+        const cpptools: apit.CppToolsTestApi = await apit.getCppToolsTestApi(api.Version.latest)
+            ?? assert.fail("Could not get CppToolsTestApi");
+        testHook = cpptools.getTestHook();
+        firstWorkspaceFolder = vscode.workspace.workspaceFolders?.[0]
+            ?? assert.fail("First workspace folder is unavailable");
+        workspaceFolder = vscode.workspace.workspaceFolders?.[1]
+            ?? assert.fail("Second workspace folder is unavailable");
+    });
+
+    suiteTeardown(function (): void {
+        testHook.dispose();
+    });
+
+    test("routes manual folding operations by URI during a workspace client switch", async () => {
+        const configuration: vscode.WorkspaceConfiguration = vscode.workspace.getConfiguration("C_Cpp", workspaceFolder.uri);
+        const previousCodeFoldingValue: string | undefined = configuration.inspect<string>("codeFolding")?.globalValue;
+        await configuration.update("codeFolding", "enabled", vscode.ConfigurationTarget.Global);
+        let releaseEditorChange: (() => void) | undefined;
+        let editorChangeStub: sinon.SinonStub | undefined;
+        let editorChangePromise: Promise<void> | undefined;
+        let editor: vscode.TextEditor | undefined;
+        let firstEditor: vscode.TextEditor | undefined;
+        try {
+            editor = await openFileAndWaitForIntelliSense();
+            await vscode.commands.executeCommand("editor.unfoldAll");
+
+            const firstDocument: vscode.TextDocument = await vscode.workspace.openTextDocument(
+                path.join(firstWorkspaceFolder.uri.fsPath, "test.cpp"));
+            firstEditor = await vscode.window.showTextDocument(firstDocument);
+            await extension.clients.didChangeActiveEditor(firstEditor);
+            const firstClient = extension.clients.ActiveClient;
+            const owner = extension.clients.getClientFor(editor.document.uri);
+            assert.notStrictEqual(firstClient, owner);
+
+            const pendingEditorChange: Promise<void> = new Promise(resolve => releaseEditorChange = resolve);
+            editorChangeStub = sinon.stub(owner, "didChangeActiveEditor").returns(pendingEditorChange);
+            const activeEditor: vscode.TextEditor = await vscode.window.showTextDocument(editor.document, editor.viewColumn, false);
+            editorChangePromise = extension.clients.didChangeActiveEditor(activeEditor);
+            assert.strictEqual(extension.clients.ActiveClient, firstClient);
+
+            await vscode.commands.executeCommand("C_Cpp.FoldAllInactiveRegions");
+            await assertInactiveBranchIsFolded(editor);
+
+            await vscode.commands.executeCommand("C_Cpp.UnfoldAllInactiveRegions");
+            await assertInactiveBranchIsUnfolded(editor);
+        } finally {
+            releaseEditorChange?.();
+            await editorChangePromise;
+            editorChangeStub?.restore();
+            if (editor) {
+                await closeEditor(editor);
+            }
+            if (firstEditor) {
+                await closeEditor(firstEditor);
+            }
+            await testHelpers.delay(150);
+            await configuration.update("codeFolding", previousCodeFoldingValue, vscode.ConfigurationTarget.Global);
+        }
+    });
+
+    async function closeEditor(editor: vscode.TextEditor): Promise<void> {
+        await vscode.window.showTextDocument(editor.document, editor.viewColumn, false);
+        await vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+    }
+
+    async function assertInactiveBranchIsFolded(editor: vscode.TextEditor): Promise<void> {
+        let line: number = 24;
+        for (let i: number = 0; i < 20; ++i) {
+            const activeEditor: vscode.TextEditor = await vscode.window.showTextDocument(editor.document, editor.viewColumn, false);
+            activeEditor.selection = new vscode.Selection(24, 0, 24, 0);
+            await vscode.commands.executeCommand("cursorMove", { to: "down", by: "wrappedLine", value: 1 });
+            line = activeEditor.selection.active.line;
+            if (line === 28) {
+                return;
+            }
+            await testHelpers.delay(50);
+        }
+
+        assert.strictEqual(line, 28);
+    }
+
+    async function assertInactiveBranchIsUnfolded(editor: vscode.TextEditor): Promise<void> {
+        const activeEditor: vscode.TextEditor = await vscode.window.showTextDocument(editor.document, editor.viewColumn, false);
+        activeEditor.selection = new vscode.Selection(24, 0, 24, 0);
+        await vscode.commands.executeCommand("cursorMove", { to: "down", by: "wrappedLine", value: 1 });
+        assert.strictEqual(activeEditor.selection.active.line, 25);
+    }
+
+    function waitForIntelliSenseReady(fileName: string): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            const timeout: NodeJS.Timeout = setTimeout(() => {
+                listener.dispose();
+                reject(new Error(`Timed out waiting for IntelliSense for ${fileName}`));
+            }, testHelpers.defaultTimeout);
+            const listener: vscode.Disposable = testHook.IntelliSenseStatusChanged(result => {
+                if (result.filename === fileName && result.status === apit.Status.IntelliSenseReady) {
+                    clearTimeout(timeout);
+                    listener.dispose();
+                    resolve();
+                }
+            });
+        });
+    }
+
+    async function openFileAndWaitForIntelliSense(): Promise<vscode.TextEditor> {
+        const fileName: string = "code_folding.cpp";
+        const filePath: string = path.join(workspaceFolder.uri.fsPath, fileName);
+        const ready: Promise<void> = waitForIntelliSenseReady(fileName);
+        const document: vscode.TextDocument = await vscode.workspace.openTextDocument(filePath);
+        const editor: vscode.TextEditor = await vscode.window.showTextDocument(document);
+        await ready;
+        return editor;
+    }
+});