Preliminary implementation of lazy CodeAssits

13 files changed, 215 insertions, 85 deletions

diff --git a/crates/ra_ide/src/lib.rs b/crates/ra_ide/src/lib.rs
index 12d5716e835..34c2d75fed2 100644
--- a/crates/ra_ide/src/lib.rs
+++ b/crates/ra_ide/src/lib.rs
@@ -77,7 +77,7 @@ pub use crate::{
 };
 
 pub use hir::Documentation;
-pub use ra_assists::{AssistConfig, AssistId};
+pub use ra_assists::{Assist, AssistConfig, AssistId, ResolvedAssist};
 pub use ra_db::{
     Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
 };
@@ -142,14 +142,6 @@ pub struct AnalysisHost {
     db: RootDatabase,
 }
 
-#[derive(Debug)]
-pub struct Assist {
-    pub id: AssistId,
-    pub label: String,
-    pub group_label: Option<String>,
-    pub source_change: SourceChange,
-}
-
 impl AnalysisHost {
     pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
         AnalysisHost { db: RootDatabase::new(lru_capacity) }
@@ -470,20 +462,23 @@ impl Analysis {
         self.with_db(|db| completion::completions(db, config, position).map(Into::into))
     }
 
-    /// Computes assists (aka code actions aka intentions) for the given
+    /// Computes resolved assists with source changes for the given position.
+    pub fn resolved_assists(
+        &self,
+        config: &AssistConfig,
+        frange: FileRange,
+    ) -> Cancelable<Vec<ResolvedAssist>> {
+        self.with_db(|db| ra_assists::Assist::resolved(db, config, frange))
+    }
+
+    /// Computes unresolved assists (aka code actions aka intentions) for the given
     /// position.
-    pub fn assists(&self, config: &AssistConfig, frange: FileRange) -> Cancelable<Vec<Assist>> {
-        self.with_db(|db| {
-            ra_assists::Assist::resolved(db, config, frange)
-                .into_iter()
-                .map(|assist| Assist {
-                    id: assist.assist.id,
-                    label: assist.assist.label,
-                    group_label: assist.assist.group.map(|it| it.0),
-                    source_change: assist.source_change,
-                })
-                .collect()
-        })
+    pub fn unresolved_assists(
+        &self,
+        config: &AssistConfig,
+        frange: FileRange,
+    ) -> Cancelable<Vec<Assist>> {
+        self.with_db(|db| Assist::unresolved(db, config, frange))
     }
 
     /// Computes the set of diagnostics for the given file.
diff --git a/crates/rust-analyzer/src/config.rs b/crates/rust-analyzer/src/config.rs
index c0f7c2c0c51..9e8e7ab824e 100644
--- a/crates/rust-analyzer/src/config.rs
+++ b/crates/rust-analyzer/src/config.rs
@@ -103,6 +103,7 @@ pub struct ClientCapsConfig {
     pub code_action_literals: bool,
     pub work_done_progress: bool,
     pub code_action_group: bool,
+    pub resolve_code_action: bool,
 }
 
 impl Default for Config {
@@ -299,7 +300,11 @@ impl Config {
 
             let code_action_group =
                 experimental.get("codeActionGroup").and_then(|it| it.as_bool()) == Some(true);
-            self.client_caps.code_action_group = code_action_group
+            self.client_caps.code_action_group = code_action_group;
+
+            let resolve_code_action =
+                experimental.get("resolveCodeAction").and_then(|it| it.as_bool()) == Some(true);
+            self.client_caps.resolve_code_action = resolve_code_action;
         }
     }
 }
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
index c40cfdcdcaf..272057b47ea 100644
--- a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
@@ -65,6 +65,7 @@ expression: diag
         fixes: [
             CodeAction {
                 title: "return the expression directly",
+                id: None,
                 group: None,
                 kind: Some(
                     "quickfix",
diff --git a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
index 6dd3fcb2eab..9a7972ff54a 100644
--- a/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
+++ b/crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
@@ -50,6 +50,7 @@ expression: diag
         fixes: [
             CodeAction {
                 title: "consider prefixing with an underscore",
+                id: None,
                 group: None,
                 kind: Some(
                     "quickfix",
diff --git a/crates/rust-analyzer/src/diagnostics/to_proto.rs b/crates/rust-analyzer/src/diagnostics/to_proto.rs
index a500d670a72..257910e0948 100644
--- a/crates/rust-analyzer/src/diagnostics/to_proto.rs
+++ b/crates/rust-analyzer/src/diagnostics/to_proto.rs
@@ -145,6 +145,7 @@ fn map_rust_child_diagnostic(
     } else {
         MappedRustChildDiagnostic::SuggestedFix(lsp_ext::CodeAction {
             title: rd.message.clone(),
+            id: None,
             group: None,
             kind: Some("quickfix".to_string()),
             edit: Some(lsp_ext::SnippetWorkspaceEdit {
diff --git a/crates/rust-analyzer/src/lsp_ext.rs b/crates/rust-analyzer/src/lsp_ext.rs
index 173c23b9e5d..05b76e7c86b 100644
--- a/crates/rust-analyzer/src/lsp_ext.rs
+++ b/crates/rust-analyzer/src/lsp_ext.rs
@@ -98,6 +98,23 @@ pub struct JoinLinesParams {
     pub ranges: Vec<Range>,
 }
 
+pub enum ResolveCodeActionRequest {}
+
+impl Request for ResolveCodeActionRequest {
+    type Params = ResolveCodeActionParams;
+    type Result = Option<SnippetWorkspaceEdit>;
+    const METHOD: &'static str = "experimental/resolveCodeAction";
+}
+
+/// Params for the ResolveCodeActionRequest
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ResolveCodeActionParams {
+    pub code_action_params: lsp_types::CodeActionParams,
+    pub id: String,
+    pub label: String,
+}
+
 pub enum OnEnter {}
 
 impl Request for OnEnter {
@@ -197,6 +214,8 @@ impl Request for CodeActionRequest {
 pub struct CodeAction {
     pub title: String,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub group: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub kind: Option<String>,
diff --git a/crates/rust-analyzer/src/main_loop.rs b/crates/rust-analyzer/src/main_loop.rs
index f1287d52cd3..ad9dd4c5961 100644
--- a/crates/rust-analyzer/src/main_loop.rs
+++ b/crates/rust-analyzer/src/main_loop.rs
@@ -517,6 +517,7 @@ fn on_request(
         .on::<lsp_ext::Runnables>(handlers::handle_runnables)?
         .on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
         .on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)?
+        .on::<lsp_ext::ResolveCodeActionRequest>(handlers::handle_resolve_code_action)?
         .on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
         .on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
         .on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?
diff --git a/crates/rust-analyzer/src/main_loop/handlers.rs b/crates/rust-analyzer/src/main_loop/handlers.rs
index bc7c7f1ef5d..b342f4bb7ea 100644
--- a/crates/rust-analyzer/src/main_loop/handlers.rs
+++ b/crates/rust-analyzer/src/main_loop/handlers.rs
@@ -693,40 +693,35 @@ pub fn handle_formatting(
     }]))
 }
 
-pub fn handle_code_action(
-    world: WorldSnapshot,
-    params: lsp_types::CodeActionParams,
-) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
-    let _p = profile("handle_code_action");
-    // We intentionally don't support command-based actions, as those either
-    // requires custom client-code anyway, or requires server-initiated edits.
-    // Server initiated edits break causality, so we avoid those as well.
-    if !world.config.client_caps.code_action_literals {
-        return Ok(None);
-    }
-
+fn handle_fixes(
+    world: &WorldSnapshot,
+    params: &lsp_types::CodeActionParams,
+    res: &mut Vec<lsp_ext::CodeAction>,
+) -> Result<()> {
     let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
     let line_index = world.analysis().file_line_index(file_id)?;
     let range = from_proto::text_range(&line_index, params.range);
-    let frange = FileRange { file_id, range };
 
     let diagnostics = world.analysis().diagnostics(file_id)?;
-    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
 
     let fixes_from_diagnostics = diagnostics
         .into_iter()
         .filter_map(|d| Some((d.range, d.fix?)))
         .filter(|(diag_range, _fix)| diag_range.intersect(range).is_some())
         .map(|(_range, fix)| fix);
-
     for fix in fixes_from_diagnostics {
         let title = fix.label;
         let edit = to_proto::snippet_workspace_edit(&world, fix.source_change)?;
-        let action =
-            lsp_ext::CodeAction { title, group: None, kind: None, edit: Some(edit), command: None };
+        let action = lsp_ext::CodeAction {
+            title,
+            id: None,
+            group: None,
+            kind: None,
+            edit: Some(edit),
+            command: None,
+        };
         res.push(action);
     }
-
     for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
         let fix_range = from_proto::text_range(&line_index, fix.range);
         if fix_range.intersect(range).is_none() {
@@ -734,13 +729,67 @@ pub fn handle_code_action(
         }
         res.push(fix.action.clone());
     }
+    Ok(())
+}
+
+pub fn handle_code_action(
+    world: WorldSnapshot,
+    params: lsp_types::CodeActionParams,
+) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
+    let _p = profile("handle_code_action");
+    // We intentionally don't support command-based actions, as those either
+    // requires custom client-code anyway, or requires server-initiated edits.
+    // Server initiated edits break causality, so we avoid those as well.
+    if !world.config.client_caps.code_action_literals {
+        return Ok(None);
+    }
+
+    let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let range = from_proto::text_range(&line_index, params.range);
+    let frange = FileRange { file_id, range };
+    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
+
+    handle_fixes(&world, &params, &mut res)?;
 
-    for assist in world.analysis().assists(&world.config.assist, frange)?.into_iter() {
-        res.push(to_proto::code_action(&world, assist)?.into());
+    if world.config.client_caps.resolve_code_action {
+        for assist in world.analysis().unresolved_assists(&world.config.assist, frange)?.into_iter()
+        {
+            res.push(to_proto::unresolved_code_action(&world, assist)?.into());
+        }
+    } else {
+        for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
+            res.push(to_proto::resolved_code_action(&world, assist)?.into());
+        }
     }
+
     Ok(Some(res))
 }
 
+pub fn handle_resolve_code_action(
+    world: WorldSnapshot,
+    params: lsp_ext::ResolveCodeActionParams,
+) -> Result<Option<lsp_ext::SnippetWorkspaceEdit>> {
+    if !world.config.client_caps.resolve_code_action {
+        return Ok(None);
+    }
+
+    let _p = profile("handle_resolve_code_action");
+    let file_id = from_proto::file_id(&world, &params.code_action_params.text_document.uri)?;
+    let line_index = world.analysis().file_line_index(file_id)?;
+    let range = from_proto::text_range(&line_index, params.code_action_params.range);
+    let frange = FileRange { file_id, range };
+    let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
+
+    for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
+        res.push(to_proto::resolved_code_action(&world, assist)?.into());
+    }
+    Ok(res
+        .into_iter()
+        .find(|action| action.id.clone().unwrap() == params.id && action.title == params.label)
+        .and_then(|action| action.edit))
+}
+
 pub fn handle_code_lens(
     world: WorldSnapshot,
     params: lsp_types::CodeLensParams,
diff --git a/crates/rust-analyzer/src/to_proto.rs b/crates/rust-analyzer/src/to_proto.rs
index 2fbbb4e632d..db78c4b5c50 100644
--- a/crates/rust-analyzer/src/to_proto.rs
+++ b/crates/rust-analyzer/src/to_proto.rs
@@ -3,8 +3,8 @@ use ra_db::{FileId, FileRange};
 use ra_ide::{
     Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
     FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange, Indel,
-    InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess, Severity,
-    SourceChange, SourceFileEdit, TextEdit,
+    InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess,
+    ResolvedAssist, Severity, SourceChange, SourceFileEdit, TextEdit,
 };
 use ra_syntax::{SyntaxKind, TextRange, TextSize};
 use ra_vfs::LineEndings;
@@ -617,10 +617,41 @@ fn main() <fold>{
     }
 }
 
-pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_ext::CodeAction> {
+pub(crate) fn unresolved_code_action(
+    world: &WorldSnapshot,
+    assist: Assist,
+) -> Result<lsp_ext::CodeAction> {
     let res = lsp_ext::CodeAction {
         title: assist.label,
-        group: if world.config.client_caps.code_action_group { assist.group_label } else { None },
+        id: Some(assist.id.0.to_owned()),
+        group: assist.group.and_then(|it| {
+            if world.config.client_caps.code_action_group {
+                None
+            } else {
+                Some(it.0)
+            }
+        }),
+        kind: Some(String::new()),
+        edit: None,
+        command: None,
+    };
+    Ok(res)
+}
+
+pub(crate) fn resolved_code_action(
+    world: &WorldSnapshot,
+    assist: ResolvedAssist,
+) -> Result<lsp_ext::CodeAction> {
+    let res = lsp_ext::CodeAction {
+        title: assist.assist.label,
+        id: Some(assist.assist.id.0.to_owned()),
+        group: assist.assist.group.and_then(|it| {
+            if world.config.client_caps.code_action_group {
+                None
+            } else {
+                Some(it.0)
+            }
+        }),
         kind: Some(String::new()),
         edit: Some(snippet_workspace_edit(world, assist.source_change)?),
         command: None,
diff --git a/editors/code/src/client.ts b/editors/code/src/client.ts
index d64f9a3f979..a25091f797c 100644
--- a/editors/code/src/client.ts
+++ b/editors/code/src/client.ts
@@ -1,8 +1,11 @@
 import * as lc from 'vscode-languageclient';
 import * as vscode from 'vscode';
+import * as ra from '../src/lsp_ext';
+import * as Is from 'vscode-languageclient/lib/utils/is';
 
 import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
 import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
+import { assert } from './util';
 
 export function createClient(serverPath: string, cwd: string): lc.LanguageClient {
     // '.' Is the fallback if no folder is open
@@ -32,6 +35,8 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                 if (res === undefined) throw new Error('busy');
                 return res;
             },
+            // Using custom handling of CodeActions where each code action is resloved lazily
+            // That's why we are not waiting for any command or edits
             async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken, _next: lc.ProvideCodeActionsSignature) {
                 const params: lc.CodeActionParams = {
                     textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
@@ -43,32 +48,38 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                     const result: (vscode.CodeAction | vscode.Command)[] = [];
                     const groups = new Map<string, { index: number; items: vscode.CodeAction[] }>();
                     for (const item of values) {
+                        // In our case we expect to get code edits only from diagnostics
                         if (lc.CodeAction.is(item)) {
+                            assert(!item.command, "We don't expect to receive commands in CodeActions");
                             const action = client.protocol2CodeConverter.asCodeAction(item);
-                            const group = actionGroup(item);
-                            if (isSnippetEdit(item) || group) {
-                                action.command = {
-                                    command: "rust-analyzer.applySnippetWorkspaceEdit",
-                                    title: "",
-                                    arguments: [action.edit],
-                                };
-                                action.edit = undefined;
-                            }
-
-                            if (group) {
-                                let entry = groups.get(group);
-                                if (!entry) {
-                                    entry = { index: result.length, items: [] };
-                                    groups.set(group, entry);
-                                    result.push(action);
-                                }
-                                entry.items.push(action);
-                            } else {
+                            result.push(action);
+                            continue;
+                        }
+                        assert(isCodeActionWithoutEditsAndCommands(item), "We don't expect edits or commands here");
+                        const action = new vscode.CodeAction(item.title);
+                        const group = (item as any).group;
+                        const id = (item as any).id;
+                        const resolveParams: ra.ResolveCodeActionParams = {
+                            id: id,
+                            // TODO: delete after discussions if needed
+                            label: item.title,
+                            codeActionParams: params
+                        };
+                        action.command = {
+                            command: "rust-analyzer.resolveCodeAction",
+                            title: item.title,
+                            arguments: [resolveParams],
+                        };
+                        if (group) {
+                            let entry = groups.get(group);
+                            if (!entry) {
+                                entry = { index: result.length, items: [] };
+                                groups.set(group, entry);
                                 result.push(action);
                             }
+                            entry.items.push(action);
                         } else {
-                            const command = client.protocol2CodeConverter.asCommand(item);
-                            result.push(command);
+                            result.push(action);
                         }
                     }
                     for (const [group, { index, items }] of groups) {
@@ -80,7 +91,7 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
                                 command: "rust-analyzer.applyActionGroup",
                                 title: "",
                                 arguments: [items.map((item) => {
-                                    return { label: item.title, edit: item.command!!.arguments!![0] };
+                                    return { label: item.title, arguments: item.command!!.arguments!![0] };
                                 })],
                             };
                             result[index] = action;
@@ -119,24 +130,17 @@ class ExperimentalFeatures implements lc.StaticFeature {
         const caps: any = capabilities.experimental ?? {};
         caps.snippetTextEdit = true;
         caps.codeActionGroup = true;
+        caps.resolveCodeAction = true;
         capabilities.experimental = caps;
     }
     initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {
     }
 }
 
-function isSnippetEdit(action: lc.CodeAction): boolean {
-    const documentChanges = action.edit?.documentChanges ?? [];
-    for (const edit of documentChanges) {
-        if (lc.TextDocumentEdit.is(edit)) {
-            if (edit.edits.some((indel) => (indel as any).insertTextFormat === lc.InsertTextFormat.Snippet)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-function actionGroup(action: lc.CodeAction): string | undefined {
-    return (action as any).group;
+function isCodeActionWithoutEditsAndCommands(value: any): boolean {
+    const candidate: lc.CodeAction = value;
+    return candidate && Is.string(candidate.title) &&
+        (candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, lc.Diagnostic.is)) &&
+        (candidate.kind === void 0 || Is.string(candidate.kind)) &&
+        (candidate.edit === void 0 && candidate.command === void 0);
 }
diff --git a/editors/code/src/commands.ts b/editors/code/src/commands.ts
index 534d2a9847e..3e9c3aa0e59 100644
--- a/editors/code/src/commands.ts
+++ b/editors/code/src/commands.ts
@@ -343,10 +343,25 @@ export function showReferences(ctx: Ctx): Cmd {
 }
 
 export function applyActionGroup(_ctx: Ctx): Cmd {
-    return async (actions: { label: string; edit: vscode.WorkspaceEdit }[]) => {
+    return async (actions: { label: string; arguments: ra.ResolveCodeActionParams }[]) => {
         const selectedAction = await vscode.window.showQuickPick(actions);
         if (!selectedAction) return;
-        await applySnippetWorkspaceEdit(selectedAction.edit);
+        vscode.commands.executeCommand(
+            'rust-analyzer.resolveCodeAction',
+            selectedAction.arguments,
+        );
+    };
+}
+
+export function resolveCodeAction(ctx: Ctx): Cmd {
+    const client = ctx.client;
+    return async (params: ra.ResolveCodeActionParams) => {
+        const item: lc.WorkspaceEdit = await client.sendRequest(ra.resolveCodeAction, params);
+        if (!item) {
+            return;
+        }
+        const edit = client.protocol2CodeConverter.asWorkspaceEdit(item);
+        await applySnippetWorkspaceEdit(edit);
     };
 }
 
diff --git a/editors/code/src/lsp_ext.ts b/editors/code/src/lsp_ext.ts
index 3e0b606997f..f881bae4721 100644
--- a/editors/code/src/lsp_ext.ts
+++ b/editors/code/src/lsp_ext.ts
@@ -33,6 +33,13 @@ export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position
 
 export const parentModule = new lc.RequestType<lc.TextDocumentPositionParams, lc.LocationLink[], void>("experimental/parentModule");
 
+export interface ResolveCodeActionParams {
+    id: string;
+    label: string;
+    codeActionParams: lc.CodeActionParams;
+}
+export const resolveCodeAction = new lc.RequestType<ResolveCodeActionParams, lc.WorkspaceEdit, unknown>('experimental/resolveCodeAction');
+
 export interface JoinLinesParams {
     textDocument: lc.TextDocumentIdentifier;
     ranges: lc.Range[];
diff --git a/editors/code/src/main.ts b/editors/code/src/main.ts
index b7337621cb6..a92c676fa2d 100644
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@@ -98,6 +98,7 @@ export async function activate(context: vscode.ExtensionContext) {
     ctx.registerCommand('debugSingle', commands.debugSingle);
     ctx.registerCommand('showReferences', commands.showReferences);
     ctx.registerCommand('applySnippetWorkspaceEdit', commands.applySnippetWorkspaceEditCommand);
+    ctx.registerCommand('resolveCodeAction', commands.resolveCodeAction);
     ctx.registerCommand('applyActionGroup', commands.applyActionGroup);
 
     ctx.pushCleanup(activateTaskProvider(workspaceFolder));