Cleanup extension activation (#1491)

Refactor the extension activation method such that it only starts up the
necessary services and registers their disposables for extension
deactivation. The startup order of services has been tweaked slightly so
that it will fail fast if the toolchain is not configured properly.
Fixes a few services that were registred for disposal twice.

Fixes up `registerDebugger` so that toggling the setting works
immediately instead of silently requiring an extension restart before
taking effect.

Author: plemarquand

src/WorkspaceContext.ts

@@ -183,6 +183,8 @@ export class WorkspaceContext implements vscode.Disposable {
             this.buildStatus,
         ];
         this.lastFocusUri = vscode.window.activeTextEditor?.document.uri;
+
+        this.setupEventListeners();
     }
 
     async stop() {
@@ -278,7 +280,7 @@ export class WorkspaceContext implements vscode.Disposable {
     }
 
     /** Setup the vscode event listeners to catch folder changes and active window changes */
-    setupEventListeners() {
+    private setupEventListeners() {
         // add event listener for when a workspace folder is added/removed
         const onWorkspaceChange = vscode.workspace.onDidChangeWorkspaceFolders(event => {
             if (this === undefined) {

src/configuration.ts

@@ -15,6 +15,8 @@
 import * as vscode from "vscode";
 import * as os from "os";
 import * as path from "path";
+import { showReloadExtensionNotification } from "./ui/ReloadExtension";
+import { WorkspaceContext } from "./WorkspaceContext";
 
 export type DebugAdapters = "auto" | "lldb-dap" | "CodeLLDB";
 export type SetupCodeLLDBOptions =
@@ -502,4 +504,36 @@ function computeVscodeVar(varName: string): string | null {
     return varName in supportedVariables ? supportedVariables[varName]() : null;
 }
 
+/**
+ * Handler for configuration change events that triggers a reload of the extension
+ * if the setting changed requires one.
+ * @param ctx The workspace context.
+ * @returns A disposable that unregisters the provider when disposed.
+ */
+export function handleConfigurationChangeEvent(
+    ctx: WorkspaceContext
+): (event: vscode.ConfigurationChangeEvent) => void {
+    return (event: vscode.ConfigurationChangeEvent) => {
+        // on toolchain config change, reload window
+        if (
+            event.affectsConfiguration("swift.path") &&
+            configuration.path !== ctx.toolchain?.swiftFolderPath
+        ) {
+            showReloadExtensionNotification(
+                "Changing the Swift path requires Visual Studio Code be reloaded."
+            );
+        } else if (
+            // on sdk config change, restart sourcekit-lsp
+            event.affectsConfiguration("swift.SDK") ||
+            event.affectsConfiguration("swift.swiftSDK")
+        ) {
+            vscode.commands.executeCommand("swift.restartLSPServer");
+        } else if (event.affectsConfiguration("swift.swiftEnvironmentVariables")) {
+            showReloadExtensionNotification(
+                "Changing environment variables requires the project be reloaded."
+            );
+        }
+    };
+}
+
 export default configuration;

src/contextKeys.ts

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 import * as vscode from "vscode";
+import { Version } from "./utilities/version";
 
 /**
  * References:
@@ -82,6 +83,11 @@ interface ContextKeys {
      * Whether the swift.switchPlatform command is available.
      */
     switchPlatformAvailable: boolean;
+
+    /**
+     * Sets values for context keys that are enabled/disabled based on the toolchain version in use.
+     */
+    updateKeysBasedOnActiveVersion(toolchainVersion: Version): void;
 }
 
 /** Creates the getters and setters for the VS Code Swift extension's context keys. */
@@ -100,6 +106,15 @@ function createContextKeys(): ContextKeys {
     let switchPlatformAvailable: boolean = false;
 
     return {
+        updateKeysBasedOnActiveVersion(toolchainVersion: Version) {
+            this.createNewProjectAvailable = toolchainVersion.isGreaterThanOrEqual(
+                new Version(5, 8, 0)
+            );
+            this.switchPlatformAvailable = toolchainVersion.isGreaterThanOrEqual(
+                new Version(6, 1, 0)
+            );
+        },
+
         get isActivated() {
             return isActivated;
         },

src/debugger/debugAdapterFactory.ts

@@ -31,13 +31,34 @@ import configuration from "../configuration";
  * @returns A disposable to be disposed when the extension is deactivated
  */
 export function registerDebugger(workspaceContext: WorkspaceContext): vscode.Disposable {
-    const subscriptions: vscode.Disposable[] = [
-        registerLoggingDebugAdapterTracker(),
-        registerLLDBDebugAdapter(workspaceContext.toolchain, workspaceContext.outputChannel),
-    ];
+    let subscriptions: vscode.Disposable[] = [];
+
+    // Monitor the swift.debugger.disable setting and register automatically
+    // when the setting is changed to enable.
+    const configurationEvent = vscode.workspace.onDidChangeConfiguration(event => {
+        if (event.affectsConfiguration("swift.debugger.disable")) {
+            subscriptions.map(sub => sub.dispose());
+            subscriptions = [];
+            if (!configuration.debugger.disable) {
+                register();
+            }
+        }
+    });
+
+    function register() {
+        subscriptions.push(registerLoggingDebugAdapterTracker());
+        subscriptions.push(
+            registerLLDBDebugAdapter(workspaceContext.toolchain, workspaceContext.outputChannel)
+        );
+    }
+
+    if (!configuration.debugger.disable) {
+        register();
+    }
 
     return {
         dispose: () => {
+            configurationEvent.dispose();
             subscriptions.map(sub => sub.dispose());
         },
     };