Pin open definitions to hash on perspective change

When there's any number of definitions open and a new perspective is
selected, the definitions that were open with references based on names,
will no longer have a resolvable name if they were to be re-queried (on
a page refresh for instance). Fix this by changing all open definitions
to be referenced by hash when the perspective is changed.

src/App.elm

@@ -33,6 +33,7 @@ import UI.Tooltip as Tooltip
 import UnisonShare.SidebarContent
 import Url exposing (Url)
 import Workspace
+import Workspace.WorkspaceItems as WorkspaceItems
 
 
 
@@ -291,16 +292,29 @@ replacePerspective ({ env } as model) perspective =
         ( codebaseTree, codebaseTreeCmd ) =
             CodebaseTree.init newEnv
 
+        -- Update all open references to be hash based to ensure that we can
+        -- refresh the page and fetch them appropriately even if they are
+        -- outside of the current perspective
+        workspace =
+            Workspace.replaceWorkspaceItemReferencesWithHashOnly model.workspace
+
+        -- Re-navigate to the currently open definition by hash
+        focusedReferenceRoute =
+            workspace.workspaceItems
+                |> WorkspaceItems.focusReference
+                |> Maybe.map (Route.toDefinition model.route)
+                |> Maybe.withDefault model.route
+
         changeRouteCmd =
-            Route.replacePerspective model.navKey (Perspective.toParams perspective) model.route
+            Route.replacePerspective model.navKey (Perspective.toParams perspective) focusedReferenceRoute
 
         fetchNamespaceDetailsCmd =
             perspective
                 |> fetchNamespaceDetails
                 |> Maybe.map (Api.perform env.apiBasePath)
                 |> Maybe.withDefault Cmd.none
     in
-    ( { model | env = newEnv, codebaseTree = codebaseTree }
+    ( { model | env = newEnv, codebaseTree = codebaseTree, workspace = workspace }
     , Cmd.batch
         [ Cmd.map CodebaseTreeMsg codebaseTreeCmd
         , changeRouteCmd

src/Definition/Reference.elm

@@ -107,3 +107,19 @@ toIcon ref =
 
         DataConstructorReference _ ->
             Icon.dataConstructor
+
+
+map : (HashQualified -> HashQualified) -> Reference -> Reference
+map f ref =
+    case ref of
+        TermReference hq ->
+            TermReference (f hq)
+
+        TypeReference hq ->
+            TypeReference (f hq)
+
+        AbilityConstructorReference hq ->
+            AbilityConstructorReference (f hq)
+
+        DataConstructorReference hq ->
+            DataConstructorReference (f hq)

src/Route.elm

@@ -8,6 +8,7 @@ module Route exposing
     , navigateToPerspective
     , perspectiveParams
     , replacePerspective
+    , toDefinition
     , toRoute
     , toUrlString
     , updatePerspectiveParams

src/Workspace.elm

@@ -4,6 +4,7 @@ module Workspace exposing
     , OutMsg(..)
     , init
     , open
+    , replaceWorkspaceItemReferencesWithHashOnly
     , subscriptions
     , update
     , view
@@ -222,6 +223,15 @@ open env model ref =
     openItem env model Nothing ref
 
 
+replaceWorkspaceItemReferencesWithHashOnly : Model -> Model
+replaceWorkspaceItemReferencesWithHashOnly model =
+    let
+        workspaceItems =
+            WorkspaceItems.map WorkspaceItem.toHashReference model.workspaceItems
+    in
+    { model | workspaceItems = workspaceItems }
+
+
 openItem : Env -> WithWorkspaceItems m -> Maybe Reference -> Reference -> ( WithWorkspaceItems m, Cmd Msg, OutMsg )
 openItem env ({ workspaceItems } as model) relativeToRef ref =
     -- We don't want to refetch or replace any already open definitions, but we

src/Workspace/WorkspaceItem.elm

@@ -127,6 +127,31 @@ reference item =
             r
 
 
+{-| Convert the Reference of a WorkspaceItem to be HashOnly
+-}
+toHashReference : WorkspaceItem -> WorkspaceItem
+toHashReference workspaceItem =
+    let
+        toHashOnly hash hq =
+            case hq of
+                HQ.NameOnly _ ->
+                    HQ.HashOnly hash
+
+                HQ.HashOnly h ->
+                    HQ.HashOnly h
+
+                HQ.HashQualified _ h ->
+                    HQ.HashOnly h
+    in
+    case workspaceItem of
+        Success r d ->
+            Success (Reference.map (toHashOnly (itemHash d.item)) r) d
+
+        -- Can't change references where we don't have hash information
+        _ ->
+            workspaceItem
+
+
 {-| Builtins and Types can't be expanded, so we can skip the Medium Zoom level entirely
 TODO: Remove isTypeItem from this conditional when we can collapse types (TypeSummary)
 -}
@@ -229,6 +254,22 @@ hasDoc item =
             False
 
 
+itemHash : Item -> Hash
+itemHash item =
+    case item of
+        TermItem (Term h _ _) ->
+            h
+
+        TypeItem (Type h _ _) ->
+            h
+
+        AbilityConstructorItem (AbilityConstructor h _) ->
+            h
+
+        DataConstructorItem (DataConstructor h _) ->
+            h
+
+
 
 -- VIEW
 

src/Workspace/WorkspaceItems.elm

@@ -288,6 +288,13 @@ focus items =
             Just data.focus
 
 
+focusReference : WorkspaceItems -> Maybe Reference
+focusReference items =
+    items
+        |> focus
+        |> Maybe.map WorkspaceItem.reference
+
+
 focusOn : WorkspaceItems -> Reference -> WorkspaceItems
 focusOn items ref =
     let