fix(scm/#2525): Fix 'Git: Checkout to' command (#3791)

__Issue:__ The 'Git: Checkout to...' command wasn't working as expected.

__Defect:__ The checkout branch QuickPick menu uses some menu extension APIs that weren't currently supported, including:

1) Exthost -> Main: `$createOrUpdate`
2) Main -> Exthost: `$onDidChangeActive`, `$onDidAccept`

__Fix:__
- Refactor the extension menus to `Feature_QuickOpen`
- Implement the missing APIs

Related to #3785 
Fixes #2525

Author: bryphe

CHANGES_CURRENT.md

@@ -2,6 +2,8 @@
 
 ### Bug Fixes
 
+- #3791 - SCM: Fix 'Git: Checkout to' command (fixes #2525)
+
 ### Performance
 
 ### Documentation

bench/lib/FilterJobBench.re

@@ -15,7 +15,6 @@ let createItem = name => {
     command: _ => Oni_Model.Actions.Noop,
     icon: None,
     highlight: [],
-    handle: None,
   };
   ret;
 };

src/Exthost/Exthost.rei

@@ -2216,6 +2216,13 @@ module Request: {
       Lwt.t(option(list(Edit.SingleEditOperation.t)));
   };
 
+  module QuickOpen: {
+    let onItemSelected: (~handle: int, Client.t) => unit;
+    let onDidChangeActive:
+      (~session: int, ~handles: list(int), Client.t) => unit;
+    let onDidAccept: (~session: int, Client.t) => unit;
+  };
+
   module SCM: {
     let provideOriginalResource:
       (~handle: int, ~uri: Uri.t, Client.t) => Lwt.t(option(Uri.t));

src/Exthost/Request.re

@@ -678,6 +678,39 @@ module LanguageFeatures = {
   };
 };
 
+module QuickOpen = {
+  let onItemSelected = (~handle, client) => {
+    Client.notify(
+      ~usesCancellationToken=false,
+      ~rpcName="ExtHostQuickOpen",
+      ~method="$onItemSelected",
+      ~args=`List([`Int(handle)]),
+      client,
+    );
+  };
+
+  let onDidChangeActive = (~session, ~handles, client) => {
+    let handlesJson = handles |> List.map(handle => `Int(handle));
+    Client.notify(
+      ~usesCancellationToken=false,
+      ~rpcName="ExtHostQuickOpen",
+      ~method="$onDidChangeActive",
+      ~args=`List([`Int(session), `List(handlesJson)]),
+      client,
+    );
+  };
+
+  let onDidAccept = (~session, client) => {
+    Client.notify(
+      ~usesCancellationToken=false,
+      ~rpcName="ExtHostQuickOpen",
+      ~method="$onDidAccept",
+      ~args=`List([`Int(session)]),
+      client,
+    );
+  };
+};
+
 module SCM = {
   let provideOriginalResource = (~handle, ~uri, client) => {
     Client.request(

src/Feature/QuickOpen/Feature_QuickOpen.re

@@ -1,6 +1,26 @@
-type model = unit;
+module Model = {
+  type session = {
+    id: int,
+    resolver: Lwt.u(Exthost.Reply.t),
+  };
+
+  type t = option(session);
+  let start = (~id, ~resolver, current) =>
+    switch (current) {
+    | Some({id: previousId, _}) when previousId == id => current
+    | Some({id: previousId, _}) when previousId != id => Some({id, resolver})
+    | None => Some({id, resolver})
+    | _ => failwith("Never hit this")
+    };
 
-let initial = ();
+  let reset = (_: t) => None;
+
+  let initial = None;
+};
+
+type model = Model.t;
+
+let initial = Model.initial;
 
 exception UserCancelled;
 
@@ -12,9 +32,16 @@ type msg =
       resolver: [@opaque] Lwt.u(Exthost.Reply.t),
     })
   | Cancelled({resolver: [@opaque] Lwt.u(Exthost.Reply.t)})
+  | MenuCancelled
+  | MenuItemSelected({item: Exthost.QuickOpen.Item.t})
   | ShowInput({
       options: Exthost.InputBoxOptions.t,
       resolver: [@opaque] Lwt.u(Exthost.Reply.t),
+    })
+  | ShowQuickPick({
+      instance: int,
+      items: list(Exthost.QuickOpen.Item.t),
+      resolver: [@opaque] Lwt.u(Exthost.Reply.t),
     });
 
 type outmsg =
@@ -27,6 +54,29 @@ module Msg = {
     Exthost.Msg.QuickOpen.(
       switch (msg) {
       | Input({options, _}) => ShowInput({options, resolver})
+      | SetItems({instance, items}) =>
+        ShowQuickPick({instance, items, resolver})
+      | Show({instance, _}) => ShowQuickPick({instance, items: [], resolver})
+      | CreateOrUpdate({params}) =>
+        Exthost.QuickOpen.(
+          {
+            switch (params) {
+            | QuickInput(input) =>
+              ShowInput({
+                options: {
+                  ignoreFocusOut: false,
+                  password: false,
+                  placeHolder: input.placeholder,
+                  prompt: input.prompt,
+                  value: input.value,
+                },
+                resolver,
+              })
+            | QuickPick({id, items, _}) =>
+              ShowQuickPick({instance: id, items, resolver})
+            };
+          }
+        )
       | _ => Noop
       }
     );
@@ -42,16 +92,75 @@ module Effects = {
     Isolinear.Effect.create(~name="Feature_QuickOpen.accept", () => {
       Lwt.wakeup(resolver, Exthost.Reply.okJson(`String(text)))
     });
+
+  let selectItem =
+      (~session, ~resolver, ~item: Exthost.QuickOpen.Item.t, client) =>
+    Isolinear.Effect.create(~name="Feature_QuickOpen.select", () => {
+      Exthost.Request.QuickOpen.onDidChangeActive(
+        ~session,
+        ~handles=[item.handle],
+        client,
+      );
+
+      Exthost.Request.QuickOpen.onDidAccept(~session, client);
+
+      Lwt.wakeup(resolver, Exthost.Reply.okJson(`Int(item.handle)));
+    });
 };
 
-let update = (msg, model) =>
+let update = (~client, msg, model) =>
   switch (msg) {
   | Accepted({resolver, text}) => (
-      model,
+      model |> Model.reset,
       Effect(Effects.accept(~resolver, text)),
     )
 
-  | Cancelled({resolver}) => (model, Effect(Effects.cancel(~resolver)))
+  | Cancelled({resolver}) => (
+      model |> Model.reset,
+      Effect(Effects.cancel(~resolver)),
+    )
+
+  | MenuItemSelected({item}) =>
+    let eff =
+      switch (model) {
+      | None => Isolinear.Effect.none
+      | Some({resolver, id}) =>
+        Effects.selectItem(~session=id, ~resolver, ~item, client)
+      };
+
+    (model |> Model.reset, Effect(eff));
+
+  | MenuCancelled =>
+    let eff =
+      switch (model) {
+      | None => Isolinear.Effect.none
+      | Some({resolver, _}) => Effects.cancel(~resolver)
+      };
+    (model |> Model.reset, Effect(eff));
+
+  | ShowQuickPick({instance, items, resolver}) =>
+    let placeholderText = "";
+    let menu =
+      Feature_Quickmenu.Schema.(
+        menu(
+          ~onItemFocused=_item => Noop,
+          ~onAccepted=
+            (~text as _, ~item) => {
+              switch (item) {
+              | Some(item) => MenuItemSelected({item: item})
+              | None => MenuCancelled
+              }
+            },
+          ~onCancelled=_item => {Cancelled({resolver: resolver})},
+          ~placeholderText,
+          ~itemRenderer=Renderer.default,
+          ~toString=
+            (item: Exthost.QuickOpen.Item.t) =>
+              Exthost.QuickOpen.Item.(item.label),
+          items,
+        )
+      );
+    (model |> Model.start(~id=instance, ~resolver), ShowMenu(menu));
 
   | ShowInput({options, resolver}) =>
     let placeholderText =
@@ -69,7 +178,7 @@ let update = (msg, model) =>
           [],
         )
       );
-    (model, ShowMenu(menu));
+    (model |> Model.reset, ShowMenu(menu));
 
   | Noop => (model, Nothing)
   };

src/Feature/QuickOpen/Feature_QuickOpen.rei

@@ -15,4 +15,4 @@ module Msg: {
     (~resolver: Lwt.u(Exthost.Reply.t), Exthost.Msg.QuickOpen.msg) => msg;
 };
 
-let update: (msg, model) => (model, outmsg);
+let update: (~client: Exthost.Client.t, msg, model) => (model, outmsg);

src/Model/Actions.re

@@ -87,10 +87,6 @@ type t =
   | QuickmenuCommandlineUpdated(string, int)
   | QuickmenuUpdateRipgrepProgress(progress)
   | QuickmenuUpdateFilterProgress([@opaque] array(menuItem), progress)
-  | QuickmenuUpdateExtensionItems({
-      id: int,
-      items: list(Exthost.QuickOpen.Item.t),
-    })
   | QuickmenuSearch(string)
   | QuickmenuClose
   | QuickOpen(Feature_QuickOpen.msg)
@@ -179,19 +175,13 @@ and menuItem = {
   command: option(SplitDirection.t) => t,
   icon: [@opaque] option(IconTheme.IconDefinition.t),
   highlight: list((int, int)),
-  handle: option(int),
 }
 and quickmenuVariant =
   | CommandPalette
   | EditorsPicker
   | FilesPicker
   | OpenBuffersPicker
   | Wildmenu([@opaque] Vim.Types.cmdlineType)
-  | Extension({
-      id: int,
-      hasItems: bool,
-      resolver: [@opaque] Lwt.u(int),
-    })
 and progress =
   | Loading
   | InProgress(float)

src/Model/Quickmenu.re

@@ -16,12 +16,7 @@ and variant =
     | EditorsPicker
     | FilesPicker
     | OpenBuffersPicker
-    | Wildmenu(Vim.Types.cmdlineType)
-    | Extension({
-        id: int,
-        hasItems: bool,
-        resolver: Lwt.u(int),
-      });
+    | Wildmenu(Vim.Types.cmdlineType);
 
 let placeholderText =
   fun

src/Store/ExtensionClient.re

@@ -148,36 +148,11 @@ let create =
            )
 
       | QuickOpen(msg) =>
-        switch (msg) {
-        | QuickOpen.Show({instance, _}) =>
-          let (promise, resolver) = Lwt.task();
-          dispatch(
-            QuickmenuShow(
-              Extension({id: instance, hasItems: false, resolver}),
-            ),
-          );
-
-          promise |> Lwt.map(handle => Reply.okJson(`Int(handle)));
-        | QuickOpen.SetItems({instance, items}) =>
-          dispatch(QuickmenuUpdateExtensionItems({id: instance, items}));
-          Lwt.return(Reply.okEmpty);
-
-        // | QuickOpen.Input(_) => Lwt.return(Reply.okJson(`String("Testing")))
-        | msg =>
-          let (promise, resolver) = Lwt.task();
-          dispatch(
-            Actions.QuickOpen(Feature_QuickOpen.Msg.exthost(~resolver, msg)),
-          );
-          // TODO: Additional quick open messages
-          // Log.warnf(m =>
-          //   m(
-          //     "Unhandled QuickOpen message: %s",
-          //     Exthost.Msg.QuickOpen.show_msg(msg),
-          //   )
-          // );
-          // TODO: Pass resolver to feature
-          promise;
-        }
+        let (promise, resolver) = Lwt.task();
+        dispatch(
+          Actions.QuickOpen(Feature_QuickOpen.Msg.exthost(~resolver, msg)),
+        );
+        promise;
 
       | StatusBar(
           SetEntry({

src/Store/Features.re

@@ -2354,7 +2354,7 @@ let update =
 
   | QuickOpen(msg) =>
     let (quickOpen', outmsg) =
-      Feature_QuickOpen.update(msg, state.quickOpen);
+      Feature_QuickOpen.update(~client=extHostClient, msg, state.quickOpen);
 
     let (state', eff) =
       switch (outmsg) {