vscode: redesigned config with simplicity and Dart extension config implementation in mind

editors/code/src/client.ts

@@ -1,6 +1,6 @@
 import * as lc from 'vscode-languageclient';
+import * as vscode from 'vscode';
 
-import { window, workspace } from 'vscode';
 import { Config } from './config';
 import { ensureLanguageServerBinary } from './installation/language_server';
 
@@ -8,37 +8,39 @@ export async function createClient(config: Config): Promise<null | lc.LanguageCl
     // '.' Is the fallback if no folder is open
     // TODO?: Workspace folders support Uri's (eg: file://test.txt).
     // It might be a good idea to test if the uri points to a file.
-    const workspaceFolderPath = workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
+    const workspaceFolderPath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? '.';
 
-    const raLspServerPath = await ensureLanguageServerBinary(config.langServerSource);
+    const langServerPath = await ensureLanguageServerBinary(config.langServerBinarySource());
-    if (!raLspServerPath) return null;
+    if (!langServerPath) return null;
 
     const run: lc.Executable = {
-        command: raLspServerPath,
+        command: langServerPath,
         options: { cwd: workspaceFolderPath },
     };
     const serverOptions: lc.ServerOptions = {
         run,
         debug: run,
     };
-    const traceOutputChannel = window.createOutputChannel(
+    const traceOutputChannel = vscode.window.createOutputChannel(
         'Rust Analyzer Language Server Trace',
     );
+    const cargoWatchOpts = config.cargoWatchOptions();
+
     const clientOptions: lc.LanguageClientOptions = {
         documentSelector: [{ scheme: 'file', language: 'rust' }],
         initializationOptions: {
             publishDecorations: true,
-            lruCapacity: config.lruCapacity,
+            lruCapacity: config.lruCapacity(),
-            maxInlayHintLength: config.maxInlayHintLength,
+            maxInlayHintLength: config.maxInlayHintLength(),
-            cargoWatchEnable: config.cargoWatchOptions.enable,
+            cargoWatchEnable: cargoWatchOpts.enable,
-            cargoWatchArgs: config.cargoWatchOptions.arguments,
+            cargoWatchArgs: cargoWatchOpts.arguments,
-            cargoWatchCommand: config.cargoWatchOptions.command,
+            cargoWatchCommand: cargoWatchOpts.command,
-            cargoWatchAllTargets: config.cargoWatchOptions.allTargets,
+            cargoWatchAllTargets: cargoWatchOpts.allTargets,
-            excludeGlobs: config.excludeGlobs,
+            excludeGlobs: config.excludeGlobs(),
-            useClientWatching: config.useClientWatching,
+            useClientWatching: config.useClientWatching(),
-            featureFlags: config.featureFlags,
+            featureFlags: config.featureFlags(),
-            withSysroot: config.withSysroot,
+            withSysroot: config.withSysroot(),
-            cargoFeatures: config.cargoFeatures,
+            cargoFeatures: config.cargoFeatures(),
         },
         traceOutputChannel,
     };

editors/code/src/config.ts

@@ -16,45 +16,48 @@ export interface CargoFeatures {
     allFeatures: boolean;
     features: string[];
 }
-
 export class Config {
-    langServerSource!: null | BinarySource;
+    private static readonly rootSection = "rust-analyzer";
+    private static readonly requiresReloadOpts = [
+        "cargoFeatures",
+        "cargo-watch",
+    ]
+    .map(opt => `${Config.rootSection}.${opt}`);
 
-    highlightingOn = true;
+    private cfg!: vscode.WorkspaceConfiguration;
-    rainbowHighlightingOn = false;
-    enableEnhancedTyping = true;
-    lruCapacity: null | number = null;
-    displayInlayHints = true;
-    maxInlayHintLength: null | number = null;
-    excludeGlobs: string[] = [];
-    useClientWatching = true;
-    featureFlags: Record<string, boolean> = {};
-    // for internal use
-    withSysroot: null | boolean = null;
-    cargoWatchOptions: CargoWatchOptions = {
-        enable: true,
-        arguments: [],
-        command: '',
-        allTargets: true,
-    };
-    cargoFeatures: CargoFeatures = {
-        noDefaultFeatures: false,
-        allFeatures: true,
-        features: [],
-    };
 
-    private prevEnhancedTyping: null | boolean = null;
+    private refreshConfig() {
-    private prevCargoFeatures: null | CargoFeatures = null;
+        this.cfg = vscode.workspace.getConfiguration(Config.rootSection);
-    private prevCargoWatchOptions: null | CargoWatchOptions = null;
+        console.log("Using configuration:", this.cfg);
-
-    constructor(ctx: vscode.ExtensionContext) {
-        vscode.workspace.onDidChangeConfiguration(_ => this.refresh(ctx), null, ctx.subscriptions);
-        this.refresh(ctx);
     }
 
-    private static expandPathResolving(path: string) {
+    constructor(private ctx: vscode.ExtensionContext) {
-        if (path.startsWith('~/')) {
+        vscode.workspace.onDidChangeConfiguration(this.onConfigChange, this, ctx.subscriptions);
-            return path.replace('~', os.homedir());
+        this.refreshConfig();
+    }
+
+    async onConfigChange(event: vscode.ConfigurationChangeEvent) {
+        this.refreshConfig();
+
+        const requiresReloadOpt = Config.requiresReloadOpts.find(
+            opt => event.affectsConfiguration(opt)
+        );
+
+        if (!requiresReloadOpt) return;
+
+        const userResponse = await vscode.window.showInformationMessage(
+            `Changing "${requiresReloadOpt}" requires a reload`,
+            "Reload now"
+        );
+
+        if (userResponse === "Reload now") {
+            vscode.commands.executeCommand("workbench.action.reloadWindow");
+        }
+    }
+
+    private static replaceTildeWithHomeDir(path: string) {
+        if (path.startsWith("~/")) {
+            return os.homedir() + path.slice("~".length);
         }
         return path;
     }
@@ -97,16 +100,13 @@ export class Config {
         }
     }
 
-    private static langServerBinarySource(
+    langServerBinarySource(): null | BinarySource {
-        ctx: vscode.ExtensionContext,
+        const langServerPath = RA_LSP_DEBUG ?? this.cfg.get<null | string>("raLspServerPath");
-        config: vscode.WorkspaceConfiguration
-    ): null | BinarySource {
-        const langServerPath = RA_LSP_DEBUG ?? config.get<null | string>("raLspServerPath");
 
         if (langServerPath) {
             return {
                 type: BinarySource.Type.ExplicitPath,
-                path: Config.expandPathResolving(langServerPath)
+                path: Config.replaceTildeWithHomeDir(langServerPath)
             };
         }
 
@@ -118,7 +118,7 @@ export class Config {
 
         return {
             type: BinarySource.Type.GithubRelease,
-            dir: ctx.globalStoragePath,
+            dir:  this.ctx.globalStoragePath,
             file: prebuiltBinaryName,
             repo: {
                 name: "rust-analyzer",
@@ -127,158 +127,36 @@ export class Config {
         };
     }
 
+    // We don't do runtime config validation here for simplicity. More on stackoverflow:
+    // https://stackoverflow.com/questions/60135780/what-is-the-best-way-to-type-check-the-configuration-for-vscode-extension
 
-    // FIXME: revisit the logic for `if (.has(...)) config.get(...)` set default
+    // FIXME: add codegen for primitive configurations
-    // values only in one place (i.e. remove default values from non-readonly members declarations)
+    highlightingOn()        { return this.cfg.get("highlightingOn") as boolean; }
-    private refresh(ctx: vscode.ExtensionContext) {
+    rainbowHighlightingOn() { return this.cfg.get("rainbowHighlightingOn") as boolean; }
-        const config = vscode.workspace.getConfiguration('rust-analyzer');
+    lruCapacity()           { return this.cfg.get("lruCapacity") as null | number; }
+    displayInlayHints()     { return this.cfg.get("displayInlayHints") as boolean; }
+    maxInlayHintLength()    { return this.cfg.get("maxInlayHintLength") as number; }
+    excludeGlobs()          { return this.cfg.get("excludeGlobs") as string[]; }
+    useClientWatching()     { return this.cfg.get("useClientWatching") as boolean; }
+    featureFlags()          { return this.cfg.get("featureFlags") as Record<string, boolean>; }
 
-        let requireReloadMessage = null;
+    cargoWatchOptions(): CargoWatchOptions {
-
+        return {
-        if (config.has('highlightingOn')) {
+            enable:     this.cfg.get("cargo-watch.enable") as boolean,
-            this.highlightingOn = config.get('highlightingOn') as boolean;
+            arguments:  this.cfg.get("cargo-watch.arguments") as string[],
-        }
+            allTargets: this.cfg.get("cargo-watch.allTargets") as boolean,
-
+            command:    this.cfg.get("cargo-watch.command") as string,
-        if (config.has('rainbowHighlightingOn')) {
+        };
-            this.rainbowHighlightingOn = config.get(
-                'rainbowHighlightingOn',
-            ) as boolean;
-        }
-
-        if (config.has('enableEnhancedTyping')) {
-            this.enableEnhancedTyping = config.get(
-                'enableEnhancedTyping',
-            ) as boolean;
-
-            if (this.prevEnhancedTyping === null) {
-                this.prevEnhancedTyping = this.enableEnhancedTyping;
-            }
-        } else if (this.prevEnhancedTyping === null) {
-            this.prevEnhancedTyping = this.enableEnhancedTyping;
-        }
-
-        if (this.prevEnhancedTyping !== this.enableEnhancedTyping) {
-            requireReloadMessage =
-                'Changing enhanced typing setting requires a reload';
-            this.prevEnhancedTyping = this.enableEnhancedTyping;
-        }
-
-        this.langServerSource = Config.langServerBinarySource(ctx, config);
-
-        if (config.has('cargo-watch.enable')) {
-            this.cargoWatchOptions.enable = config.get<boolean>(
-                'cargo-watch.enable',
-                true,
-            );
-        }
-
-        if (config.has('cargo-watch.arguments')) {
-            this.cargoWatchOptions.arguments = config.get<string[]>(
-                'cargo-watch.arguments',
-                [],
-            );
-        }
-
-        if (config.has('cargo-watch.command')) {
-            this.cargoWatchOptions.command = config.get<string>(
-                'cargo-watch.command',
-                '',
-            );
-        }
-
-        if (config.has('cargo-watch.allTargets')) {
-            this.cargoWatchOptions.allTargets = config.get<boolean>(
-                'cargo-watch.allTargets',
-                true,
-            );
-        }
-
-        if (config.has('lruCapacity')) {
-            this.lruCapacity = config.get('lruCapacity') as number;
-        }
-
-        if (config.has('displayInlayHints')) {
-            this.displayInlayHints = config.get('displayInlayHints') as boolean;
-        }
-        if (config.has('maxInlayHintLength')) {
-            this.maxInlayHintLength = config.get(
-                'maxInlayHintLength',
-            ) as number;
-        }
-        if (config.has('excludeGlobs')) {
-            this.excludeGlobs = config.get('excludeGlobs') || [];
-        }
-        if (config.has('useClientWatching')) {
-            this.useClientWatching = config.get('useClientWatching') || true;
-        }
-        if (config.has('featureFlags')) {
-            this.featureFlags = config.get('featureFlags') || {};
-        }
-        if (config.has('withSysroot')) {
-            this.withSysroot = config.get('withSysroot') || false;
-        }
-
-        if (config.has('cargoFeatures.noDefaultFeatures')) {
-            this.cargoFeatures.noDefaultFeatures = config.get(
-                'cargoFeatures.noDefaultFeatures',
-                false,
-            );
-        }
-        if (config.has('cargoFeatures.allFeatures')) {
-            this.cargoFeatures.allFeatures = config.get(
-                'cargoFeatures.allFeatures',
-                true,
-            );
-        }
-        if (config.has('cargoFeatures.features')) {
-            this.cargoFeatures.features = config.get(
-                'cargoFeatures.features',
-                [],
-            );
-        }
-
-        if (
-            this.prevCargoFeatures !== null &&
-            (this.cargoFeatures.allFeatures !==
-                this.prevCargoFeatures.allFeatures ||
-                this.cargoFeatures.noDefaultFeatures !==
-                this.prevCargoFeatures.noDefaultFeatures ||
-                this.cargoFeatures.features.length !==
-                this.prevCargoFeatures.features.length ||
-                this.cargoFeatures.features.some(
-                    (v, i) => v !== this.prevCargoFeatures!.features[i],
-                ))
-        ) {
-            requireReloadMessage = 'Changing cargo features requires a reload';
-        }
-        this.prevCargoFeatures = { ...this.cargoFeatures };
-
-        if (this.prevCargoWatchOptions !== null) {
-            const changed =
-                this.cargoWatchOptions.enable !== this.prevCargoWatchOptions.enable ||
-                this.cargoWatchOptions.command !== this.prevCargoWatchOptions.command ||
-                this.cargoWatchOptions.allTargets !== this.prevCargoWatchOptions.allTargets ||
-                this.cargoWatchOptions.arguments.length !== this.prevCargoWatchOptions.arguments.length ||
-                this.cargoWatchOptions.arguments.some(
-                    (v, i) => v !== this.prevCargoWatchOptions!.arguments[i],
-                );
-            if (changed) {
-                requireReloadMessage = 'Changing cargo-watch options requires a reload';
-            }
-        }
-        this.prevCargoWatchOptions = { ...this.cargoWatchOptions };
-
-        if (requireReloadMessage !== null) {
-            const reloadAction = 'Reload now';
-            vscode.window
-                .showInformationMessage(requireReloadMessage, reloadAction)
-                .then(selectedAction => {
-                    if (selectedAction === reloadAction) {
-                        vscode.commands.executeCommand(
-                            'workbench.action.reloadWindow',
-                        );
-                    }
-                });
-        }
     }
+
+    cargoFeatures(): CargoFeatures {
+        return {
+            noDefaultFeatures: this.cfg.get("cargoFeatures.noDefaultFeatures") as boolean,
+            allFeatures:       this.cfg.get("cargoFeatures.allFeatures") as boolean,
+            features:          this.cfg.get("cargoFeatures.features") as string[],
+        };
+    }
+
+    // for internal use
+    withSysroot() { return this.cfg.get("withSysroot", false); }
 }

editors/code/src/highlighting.ts

@@ -11,7 +11,7 @@ export function activateHighlighting(ctx: Ctx) {
         client.onNotification(
             'rust-analyzer/publishDecorations',
             (params: PublishDecorationsParams) => {
-                if (!ctx.config.highlightingOn) return;
+                if (!ctx.config.highlightingOn()) return;
 
                 const targetEditor = vscode.window.visibleTextEditors.find(
                     editor => {
@@ -39,7 +39,7 @@ export function activateHighlighting(ctx: Ctx) {
     vscode.window.onDidChangeActiveTextEditor(
         async (editor: vscode.TextEditor | undefined) => {
             if (!editor || editor.document.languageId !== 'rust') return;
-            if (!ctx.config.highlightingOn) return;
+            if (!ctx.config.highlightingOn()) return;
             const client = ctx.client;
             if (!client) return;
 
@@ -122,7 +122,7 @@ class Highlighter {
             string,
             [vscode.Range[], boolean]
         > = new Map();
-        const rainbowTime = this.ctx.config.rainbowHighlightingOn;
+        const rainbowTime = this.ctx.config.rainbowHighlightingOn();
 
         for (const tag of this.decorations.keys()) {
             byTag.set(tag, []);

editors/code/src/inlay_hints.ts

@@ -22,12 +22,12 @@ export function activateInlayHints(ctx: Ctx) {
     );
 
     vscode.workspace.onDidChangeConfiguration(
-        async _ => hintsUpdater.setEnabled(ctx.config.displayInlayHints),
+        async _ => hintsUpdater.setEnabled(ctx.config.displayInlayHints()),
         null,
         ctx.subscriptions
     );
 
-    ctx.onDidRestart(_ => hintsUpdater.setEnabled(ctx.config.displayInlayHints));
+    ctx.onDidRestart(_ => hintsUpdater.setEnabled(ctx.config.displayInlayHints()));
 }
 
 interface InlayHintsParams {
@@ -59,7 +59,7 @@ class HintsUpdater {
 
     constructor(ctx: Ctx) {
         this.ctx = ctx;
-        this.enabled = ctx.config.displayInlayHints;
+        this.enabled = ctx.config.displayInlayHints();
     }
 
     async setEnabled(enabled: boolean) {

editors/code/src/status_display.ts

@@ -7,7 +7,7 @@ import { Ctx } from './ctx';
 const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
 export function activateStatusDisplay(ctx: Ctx) {
-    const statusDisplay = new StatusDisplay(ctx.config.cargoWatchOptions.command);
+    const statusDisplay = new StatusDisplay(ctx.config.cargoWatchOptions().command);
     ctx.pushCleanup(statusDisplay);
     ctx.onDidRestart(client => ctx.pushCleanup(client.onProgress(
         WorkDoneProgress.type,
@@ -66,9 +66,9 @@ class StatusDisplay implements Disposable {
 
     refreshLabel() {
         if (this.packageName) {
-            this.statusBarItem!.text = `${spinnerFrames[this.i]} cargo ${this.command} [${this.packageName}]`;
+            this.statusBarItem.text = `${spinnerFrames[this.i]} cargo ${this.command} [${this.packageName}]`;
         } else {
-            this.statusBarItem!.text = `${spinnerFrames[this.i]} cargo ${this.command}`;
+            this.statusBarItem.text = `${spinnerFrames[this.i]} cargo ${this.command}`;
         }
     }