{-# LANGUAGE RecordWildCards #-}

module Unison.Codebase.Editor.Output.BranchDiff where

import Control.Lens
import Data.List qualified as List
import Data.Map qualified as Map
import Data.Set qualified as Set
import Unison.Codebase.BranchDiff (BranchDiff (BranchDiff))
import Unison.Codebase.BranchDiff qualified as BranchDiff
import Unison.Codebase.Patch qualified as P
import Unison.DataDeclaration (DeclOrBuiltin)
import Unison.HashQualifiedPrime (HashQualified)
import Unison.Name (Name)
import Unison.Name qualified as Name
import Unison.Names (Names)
import Unison.Names qualified as Names
import Unison.Prelude
import Unison.Reference (Reference)
import Unison.Referent (Referent)
import Unison.Syntax.Name ()
import Unison.Type (Type)
import Unison.Util.Relation qualified as R

data BranchDiffOutput v a = BranchDiffOutput
  { forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
updatedTypes :: [UpdateTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
updatedTerms :: [UpdateTermDisplay v a],
    forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
newTypeConflicts :: [UpdateTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
newTermConflicts :: [UpdateTermDisplay v a],
    forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
resolvedTypeConflicts :: [UpdateTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
resolvedTermConflicts :: [UpdateTermDisplay v a],
    forall v a. BranchDiffOutput v a -> [PatchDisplay]
updatedPatches :: [PatchDisplay],
    forall v a. BranchDiffOutput v a -> [AddedTypeDisplay v a]
addedTypes :: [AddedTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [AddedTermDisplay v a]
addedTerms :: [AddedTermDisplay v a],
    forall v a. BranchDiffOutput v a -> [PatchDisplay]
addedPatches :: [PatchDisplay],
    forall v a. BranchDiffOutput v a -> [AddedTypeDisplay v a]
removedTypes :: [RemovedTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [AddedTermDisplay v a]
removedTerms :: [RemovedTermDisplay v a],
    forall v a. BranchDiffOutput v a -> [PatchDisplay]
removedPatches :: [PatchDisplay],
    forall v a. BranchDiffOutput v a -> [RenameTypeDisplay v a]
renamedTypes :: [RenameTypeDisplay v a],
    forall v a. BranchDiffOutput v a -> [RenameTermDisplay v a]
renamedTerms :: [RenameTermDisplay v a]
  }
  deriving (Int -> BranchDiffOutput v a -> ShowS
[BranchDiffOutput v a] -> ShowS
BranchDiffOutput v a -> String
(Int -> BranchDiffOutput v a -> ShowS)
-> (BranchDiffOutput v a -> String)
-> ([BranchDiffOutput v a] -> ShowS)
-> Show (BranchDiffOutput v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall v a.
(Show a, Show v) =>
Int -> BranchDiffOutput v a -> ShowS
forall v a. (Show a, Show v) => [BranchDiffOutput v a] -> ShowS
forall v a. (Show a, Show v) => BranchDiffOutput v a -> String
$cshowsPrec :: forall v a.
(Show a, Show v) =>
Int -> BranchDiffOutput v a -> ShowS
showsPrec :: Int -> BranchDiffOutput v a -> ShowS
$cshow :: forall v a. (Show a, Show v) => BranchDiffOutput v a -> String
show :: BranchDiffOutput v a -> String
$cshowList :: forall v a. (Show a, Show v) => [BranchDiffOutput v a] -> ShowS
showList :: [BranchDiffOutput v a] -> ShowS
Show)

isEmpty :: BranchDiffOutput v a -> Bool
isEmpty :: forall v a. BranchDiffOutput v a -> Bool
isEmpty BranchDiffOutput {[PatchDisplay]
[RemovedTypeDisplay v a]
[RemovedTermDisplay v a]
[RenameTypeDisplay v a]
[RenameTermDisplay v a]
[UpdateTypeDisplay v a]
[UpdateTermDisplay v a]
$sel:updatedTypes:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
$sel:updatedTerms:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
$sel:newTypeConflicts:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
$sel:newTermConflicts:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
$sel:resolvedTypeConflicts:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTypeDisplay v a]
$sel:resolvedTermConflicts:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [UpdateTermDisplay v a]
$sel:updatedPatches:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [PatchDisplay]
$sel:addedTypes:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [AddedTypeDisplay v a]
$sel:addedTerms:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [AddedTermDisplay v a]
$sel:addedPatches:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [PatchDisplay]
$sel:removedTypes:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [AddedTypeDisplay v a]
$sel:removedTerms:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [AddedTermDisplay v a]
$sel:removedPatches:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [PatchDisplay]
$sel:renamedTypes:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [RenameTypeDisplay v a]
$sel:renamedTerms:BranchDiffOutput :: forall v a. BranchDiffOutput v a -> [RenameTermDisplay v a]
updatedTypes :: [UpdateTypeDisplay v a]
updatedTerms :: [UpdateTermDisplay v a]
newTypeConflicts :: [UpdateTypeDisplay v a]
newTermConflicts :: [UpdateTermDisplay v a]
resolvedTypeConflicts :: [UpdateTypeDisplay v a]
resolvedTermConflicts :: [UpdateTermDisplay v a]
updatedPatches :: [PatchDisplay]
addedTypes :: [RemovedTypeDisplay v a]
addedTerms :: [RemovedTermDisplay v a]
addedPatches :: [PatchDisplay]
removedTypes :: [RemovedTypeDisplay v a]
removedTerms :: [RemovedTermDisplay v a]
removedPatches :: [PatchDisplay]
renamedTypes :: [RenameTypeDisplay v a]
renamedTerms :: [RenameTermDisplay v a]
..} =
  [UpdateTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTypeDisplay v a]
updatedTypes
    Bool -> Bool -> Bool
&& [UpdateTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTermDisplay v a]
updatedTerms
    Bool -> Bool -> Bool
&& [UpdateTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTypeDisplay v a]
newTypeConflicts
    Bool -> Bool -> Bool
&& [UpdateTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTermDisplay v a]
newTermConflicts
    Bool -> Bool -> Bool
&& [UpdateTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTypeDisplay v a]
resolvedTypeConflicts
    Bool -> Bool -> Bool
&& [UpdateTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [UpdateTermDisplay v a]
resolvedTermConflicts
    Bool -> Bool -> Bool
&& [RemovedTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RemovedTypeDisplay v a]
addedTypes
    Bool -> Bool -> Bool
&& [RemovedTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RemovedTermDisplay v a]
addedTerms
    Bool -> Bool -> Bool
&& [PatchDisplay] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [PatchDisplay]
addedPatches
    Bool -> Bool -> Bool
&& [RemovedTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RemovedTypeDisplay v a]
removedTypes
    Bool -> Bool -> Bool
&& [RemovedTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RemovedTermDisplay v a]
removedTerms
    Bool -> Bool -> Bool
&& [PatchDisplay] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [PatchDisplay]
removedPatches
    Bool -> Bool -> Bool
&& [RenameTypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RenameTypeDisplay v a]
renamedTypes
    Bool -> Bool -> Bool
&& [RenameTermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [RenameTermDisplay v a]
renamedTerms
    Bool -> Bool -> Bool
&& [PatchDisplay] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [PatchDisplay]
updatedPatches

-- Need to be able to turn a (Name,Reference) into a HashQualified relative to... what.
-- the new namespace?

data TermDisplay v a = TermDisplay
  { forall v a. TermDisplay v a -> HashQualified Name
name :: HashQualified Name,
    forall v a. TermDisplay v a -> Referent' (Reference' Text Hash)
ref :: Referent,
    forall v a. TermDisplay v a -> Maybe (Type v a)
type_ :: Maybe (Type v a)
  }
  deriving stock ((forall x. TermDisplay v a -> Rep (TermDisplay v a) x)
-> (forall x. Rep (TermDisplay v a) x -> TermDisplay v a)
-> Generic (TermDisplay v a)
forall x. Rep (TermDisplay v a) x -> TermDisplay v a
forall x. TermDisplay v a -> Rep (TermDisplay v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v a x. Rep (TermDisplay v a) x -> TermDisplay v a
forall v a x. TermDisplay v a -> Rep (TermDisplay v a) x
$cfrom :: forall v a x. TermDisplay v a -> Rep (TermDisplay v a) x
from :: forall x. TermDisplay v a -> Rep (TermDisplay v a) x
$cto :: forall v a x. Rep (TermDisplay v a) x -> TermDisplay v a
to :: forall x. Rep (TermDisplay v a) x -> TermDisplay v a
Generic, Int -> TermDisplay v a -> ShowS
[TermDisplay v a] -> ShowS
TermDisplay v a -> String
(Int -> TermDisplay v a -> ShowS)
-> (TermDisplay v a -> String)
-> ([TermDisplay v a] -> ShowS)
-> Show (TermDisplay v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall v a. Show v => Int -> TermDisplay v a -> ShowS
forall v a. Show v => [TermDisplay v a] -> ShowS
forall v a. Show v => TermDisplay v a -> String
$cshowsPrec :: forall v a. Show v => Int -> TermDisplay v a -> ShowS
showsPrec :: Int -> TermDisplay v a -> ShowS
$cshow :: forall v a. Show v => TermDisplay v a -> String
show :: TermDisplay v a -> String
$cshowList :: forall v a. Show v => [TermDisplay v a] -> ShowS
showList :: [TermDisplay v a] -> ShowS
Show)

instance Eq (TermDisplay v a) where
  TermDisplay v a
t0 == :: TermDisplay v a -> TermDisplay v a -> Bool
== TermDisplay v a
t1 =
    (TermDisplay v a
t0 TermDisplay v a
-> Getting
     (Referent' (Reference' Text Hash))
     (TermDisplay v a)
     (Referent' (Reference' Text Hash))
-> Referent' (Reference' Text Hash)
forall s a. s -> Getting a s a -> a
^. Getting
  (Referent' (Reference' Text Hash))
  (TermDisplay v a)
  (Referent' (Reference' Text Hash))
#ref Referent' (Reference' Text Hash)
-> Referent' (Reference' Text Hash) -> Bool
forall a. Eq a => a -> a -> Bool
== TermDisplay v a
t1 TermDisplay v a
-> Getting
     (Referent' (Reference' Text Hash))
     (TermDisplay v a)
     (Referent' (Reference' Text Hash))
-> Referent' (Reference' Text Hash)
forall s a. s -> Getting a s a -> a
^. Getting
  (Referent' (Reference' Text Hash))
  (TermDisplay v a)
  (Referent' (Reference' Text Hash))
#ref) Bool -> Bool -> Bool
&& (TermDisplay v a
t0 TermDisplay v a
-> Getting
     (HashQualified Name) (TermDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TermDisplay v a) (HashQualified Name)
#name HashQualified Name -> HashQualified Name -> Bool
forall a. Eq a => a -> a -> Bool
== TermDisplay v a
t1 TermDisplay v a
-> Getting
     (HashQualified Name) (TermDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TermDisplay v a) (HashQualified Name)
#name)

-- | Compare term displays on name.
instance Ord (TermDisplay v a) where
  compare :: TermDisplay v a -> TermDisplay v a -> Ordering
compare TermDisplay v a
t0 TermDisplay v a
t1 =
    HashQualified Name -> HashQualified Name -> Ordering
forall n. Alphabetical n => n -> n -> Ordering
Name.compareAlphabetical (TermDisplay v a
t0 TermDisplay v a
-> Getting
     (HashQualified Name) (TermDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TermDisplay v a) (HashQualified Name)
#name) (TermDisplay v a
t1 TermDisplay v a
-> Getting
     (HashQualified Name) (TermDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TermDisplay v a) (HashQualified Name)
#name) Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Referent' (Reference' Text Hash)
-> Referent' (Reference' Text Hash) -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (TermDisplay v a
t0 TermDisplay v a
-> Getting
     (Referent' (Reference' Text Hash))
     (TermDisplay v a)
     (Referent' (Reference' Text Hash))
-> Referent' (Reference' Text Hash)
forall s a. s -> Getting a s a -> a
^. Getting
  (Referent' (Reference' Text Hash))
  (TermDisplay v a)
  (Referent' (Reference' Text Hash))
#ref) (TermDisplay v a
t1 TermDisplay v a
-> Getting
     (Referent' (Reference' Text Hash))
     (TermDisplay v a)
     (Referent' (Reference' Text Hash))
-> Referent' (Reference' Text Hash)
forall s a. s -> Getting a s a -> a
^. Getting
  (Referent' (Reference' Text Hash))
  (TermDisplay v a)
  (Referent' (Reference' Text Hash))
#ref)

data TypeDisplay v a = TypeDisplay
  { forall v a. TypeDisplay v a -> HashQualified Name
name :: HashQualified Name,
    forall v a. TypeDisplay v a -> Reference' Text Hash
ref :: Reference,
    forall v a. TypeDisplay v a -> Maybe (DeclOrBuiltin v a)
decl :: Maybe (DeclOrBuiltin v a)
  }
  deriving stock ((forall x. TypeDisplay v a -> Rep (TypeDisplay v a) x)
-> (forall x. Rep (TypeDisplay v a) x -> TypeDisplay v a)
-> Generic (TypeDisplay v a)
forall x. Rep (TypeDisplay v a) x -> TypeDisplay v a
forall x. TypeDisplay v a -> Rep (TypeDisplay v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v a x. Rep (TypeDisplay v a) x -> TypeDisplay v a
forall v a x. TypeDisplay v a -> Rep (TypeDisplay v a) x
$cfrom :: forall v a x. TypeDisplay v a -> Rep (TypeDisplay v a) x
from :: forall x. TypeDisplay v a -> Rep (TypeDisplay v a) x
$cto :: forall v a x. Rep (TypeDisplay v a) x -> TypeDisplay v a
to :: forall x. Rep (TypeDisplay v a) x -> TypeDisplay v a
Generic, Int -> TypeDisplay v a -> ShowS
[TypeDisplay v a] -> ShowS
TypeDisplay v a -> String
(Int -> TypeDisplay v a -> ShowS)
-> (TypeDisplay v a -> String)
-> ([TypeDisplay v a] -> ShowS)
-> Show (TypeDisplay v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall v a. (Show a, Show v) => Int -> TypeDisplay v a -> ShowS
forall v a. (Show a, Show v) => [TypeDisplay v a] -> ShowS
forall v a. (Show a, Show v) => TypeDisplay v a -> String
$cshowsPrec :: forall v a. (Show a, Show v) => Int -> TypeDisplay v a -> ShowS
showsPrec :: Int -> TypeDisplay v a -> ShowS
$cshow :: forall v a. (Show a, Show v) => TypeDisplay v a -> String
show :: TypeDisplay v a -> String
$cshowList :: forall v a. (Show a, Show v) => [TypeDisplay v a] -> ShowS
showList :: [TypeDisplay v a] -> ShowS
Show)

instance Eq (TypeDisplay v a) where
  TypeDisplay v a
t0 == :: TypeDisplay v a -> TypeDisplay v a -> Bool
== TypeDisplay v a
t1 =
    (TypeDisplay v a
t0 TypeDisplay v a
-> Getting
     (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
-> Reference' Text Hash
forall s a. s -> Getting a s a -> a
^. Getting
  (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
#ref Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== TypeDisplay v a
t1 TypeDisplay v a
-> Getting
     (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
-> Reference' Text Hash
forall s a. s -> Getting a s a -> a
^. Getting
  (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
#ref) Bool -> Bool -> Bool
&& (TypeDisplay v a
t0 TypeDisplay v a
-> Getting
     (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
#name HashQualified Name -> HashQualified Name -> Bool
forall a. Eq a => a -> a -> Bool
== TypeDisplay v a
t1 TypeDisplay v a
-> Getting
     (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
#name)

-- | Compare type displays on name.
instance Ord (TypeDisplay v a) where
  compare :: TypeDisplay v a -> TypeDisplay v a -> Ordering
compare TypeDisplay v a
t0 TypeDisplay v a
t1 =
    HashQualified Name -> HashQualified Name -> Ordering
forall n. Alphabetical n => n -> n -> Ordering
Name.compareAlphabetical (TypeDisplay v a
t0 TypeDisplay v a
-> Getting
     (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
#name) (TypeDisplay v a
t1 TypeDisplay v a
-> Getting
     (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
-> HashQualified Name
forall s a. s -> Getting a s a -> a
^. Getting (HashQualified Name) (TypeDisplay v a) (HashQualified Name)
#name) Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Reference' Text Hash -> Reference' Text Hash -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (TypeDisplay v a
t0 TypeDisplay v a
-> Getting
     (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
-> Reference' Text Hash
forall s a. s -> Getting a s a -> a
^. Getting
  (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
#ref) (TypeDisplay v a
t1 TypeDisplay v a
-> Getting
     (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
-> Reference' Text Hash
forall s a. s -> Getting a s a -> a
^. Getting
  (Reference' Text Hash) (TypeDisplay v a) (Reference' Text Hash)
#ref)

type AddedTermDisplay v a = ([HashQualified Name], Referent, Maybe (Type v a))

type AddedTypeDisplay v a = ([HashQualified Name], Reference, Maybe (DeclOrBuiltin v a))

type RemovedTermDisplay v a = ([HashQualified Name], Referent, Maybe (Type v a))

type RemovedTypeDisplay v a = ([HashQualified Name], Reference, Maybe (DeclOrBuiltin v a))

type SimpleTermDisplay v a = (HashQualified Name, Referent, Maybe (Type v a))

type SimpleTypeDisplay v a = (HashQualified Name, Reference, Maybe (DeclOrBuiltin v a))

data UpdateTermDisplay v a = UpdateTermDisplay
  { forall v a. UpdateTermDisplay v a -> Maybe [SimpleTermDisplay v a]
old :: Maybe [SimpleTermDisplay v a],
    forall v a. UpdateTermDisplay v a -> [TermDisplay v a]
new :: [TermDisplay v a]
  }
  deriving stock ((forall x. UpdateTermDisplay v a -> Rep (UpdateTermDisplay v a) x)
-> (forall x.
    Rep (UpdateTermDisplay v a) x -> UpdateTermDisplay v a)
-> Generic (UpdateTermDisplay v a)
forall x. Rep (UpdateTermDisplay v a) x -> UpdateTermDisplay v a
forall x. UpdateTermDisplay v a -> Rep (UpdateTermDisplay v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v a x.
Rep (UpdateTermDisplay v a) x -> UpdateTermDisplay v a
forall v a x.
UpdateTermDisplay v a -> Rep (UpdateTermDisplay v a) x
$cfrom :: forall v a x.
UpdateTermDisplay v a -> Rep (UpdateTermDisplay v a) x
from :: forall x. UpdateTermDisplay v a -> Rep (UpdateTermDisplay v a) x
$cto :: forall v a x.
Rep (UpdateTermDisplay v a) x -> UpdateTermDisplay v a
to :: forall x. Rep (UpdateTermDisplay v a) x -> UpdateTermDisplay v a
Generic, Int -> UpdateTermDisplay v a -> ShowS
[UpdateTermDisplay v a] -> ShowS
UpdateTermDisplay v a -> String
(Int -> UpdateTermDisplay v a -> ShowS)
-> (UpdateTermDisplay v a -> String)
-> ([UpdateTermDisplay v a] -> ShowS)
-> Show (UpdateTermDisplay v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall v a. Show v => Int -> UpdateTermDisplay v a -> ShowS
forall v a. Show v => [UpdateTermDisplay v a] -> ShowS
forall v a. Show v => UpdateTermDisplay v a -> String
$cshowsPrec :: forall v a. Show v => Int -> UpdateTermDisplay v a -> ShowS
showsPrec :: Int -> UpdateTermDisplay v a -> ShowS
$cshow :: forall v a. Show v => UpdateTermDisplay v a -> String
show :: UpdateTermDisplay v a -> String
$cshowList :: forall v a. Show v => [UpdateTermDisplay v a] -> ShowS
showList :: [UpdateTermDisplay v a] -> ShowS
Show)

instance Eq (UpdateTermDisplay v a) where
  UpdateTermDisplay v a
u0 == :: UpdateTermDisplay v a -> UpdateTermDisplay v a -> Bool
== UpdateTermDisplay v a
u1 = (UpdateTermDisplay v a
u0 UpdateTermDisplay v a
-> Getting
     (First (TermDisplay v a)) (UpdateTermDisplay v a) (TermDisplay v a)
-> Maybe (TermDisplay v a)
forall s a. s -> Getting (First a) s a -> Maybe a
^? ([TermDisplay v a]
 -> Const (First (TermDisplay v a)) [TermDisplay v a])
-> UpdateTermDisplay v a
-> Const (First (TermDisplay v a)) (UpdateTermDisplay v a)
#new (([TermDisplay v a]
  -> Const (First (TermDisplay v a)) [TermDisplay v a])
 -> UpdateTermDisplay v a
 -> Const (First (TermDisplay v a)) (UpdateTermDisplay v a))
-> ((TermDisplay v a
     -> Const (First (TermDisplay v a)) (TermDisplay v a))
    -> [TermDisplay v a]
    -> Const (First (TermDisplay v a)) [TermDisplay v a])
-> Getting
     (First (TermDisplay v a)) (UpdateTermDisplay v a) (TermDisplay v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TermDisplay v a
 -> Const (First (TermDisplay v a)) (TermDisplay v a))
-> [TermDisplay v a]
-> Const (First (TermDisplay v a)) [TermDisplay v a]
forall s a. Cons s s a a => Traversal' s a
Traversal' [TermDisplay v a] (TermDisplay v a)
_head) Maybe (TermDisplay v a) -> Maybe (TermDisplay v a) -> Bool
forall a. Eq a => a -> a -> Bool
== (UpdateTermDisplay v a
u1 UpdateTermDisplay v a
-> Getting
     (First (TermDisplay v a)) (UpdateTermDisplay v a) (TermDisplay v a)
-> Maybe (TermDisplay v a)
forall s a. s -> Getting (First a) s a -> Maybe a
^? ([TermDisplay v a]
 -> Const (First (TermDisplay v a)) [TermDisplay v a])
-> UpdateTermDisplay v a
-> Const (First (TermDisplay v a)) (UpdateTermDisplay v a)
#new (([TermDisplay v a]
  -> Const (First (TermDisplay v a)) [TermDisplay v a])
 -> UpdateTermDisplay v a
 -> Const (First (TermDisplay v a)) (UpdateTermDisplay v a))
-> ((TermDisplay v a
     -> Const (First (TermDisplay v a)) (TermDisplay v a))
    -> [TermDisplay v a]
    -> Const (First (TermDisplay v a)) [TermDisplay v a])
-> Getting
     (First (TermDisplay v a)) (UpdateTermDisplay v a) (TermDisplay v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TermDisplay v a
 -> Const (First (TermDisplay v a)) (TermDisplay v a))
-> [TermDisplay v a]
-> Const (First (TermDisplay v a)) [TermDisplay v a]
forall s a. Cons s s a a => Traversal' s a
Traversal' [TermDisplay v a] (TermDisplay v a)
_head)

instance Ord (UpdateTermDisplay v a) where
  compare :: UpdateTermDisplay v a -> UpdateTermDisplay v a -> Ordering
compare UpdateTermDisplay v a
u0 UpdateTermDisplay v a
u1 =
    case (UpdateTermDisplay v a
u0 UpdateTermDisplay v a
-> Getting
     [TermDisplay v a] (UpdateTermDisplay v a) [TermDisplay v a]
-> [TermDisplay v a]
forall s a. s -> Getting a s a -> a
^. Getting [TermDisplay v a] (UpdateTermDisplay v a) [TermDisplay v a]
#new, UpdateTermDisplay v a
u1 UpdateTermDisplay v a
-> Getting
     [TermDisplay v a] (UpdateTermDisplay v a) [TermDisplay v a]
-> [TermDisplay v a]
forall s a. s -> Getting a s a -> a
^. Getting [TermDisplay v a] (UpdateTermDisplay v a) [TermDisplay v a]
#new) of
      (TermDisplay v a
t0 : [TermDisplay v a]
_, TermDisplay v a
t1 : [TermDisplay v a]
_) -> TermDisplay v a -> TermDisplay v a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare TermDisplay v a
t0 TermDisplay v a
t1
      ([TermDisplay v a]
ts0, [TermDisplay v a]
ts1) -> Bool -> Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([TermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TermDisplay v a]
ts0) ([TermDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TermDisplay v a]
ts1)

data UpdateTypeDisplay v a = UpdateTypeDisplay
  { forall v a. UpdateTypeDisplay v a -> Maybe [SimpleTypeDisplay v a]
old :: Maybe [SimpleTypeDisplay v a],
    forall v a. UpdateTypeDisplay v a -> [TypeDisplay v a]
new :: [TypeDisplay v a]
  }
  deriving stock ((forall x. UpdateTypeDisplay v a -> Rep (UpdateTypeDisplay v a) x)
-> (forall x.
    Rep (UpdateTypeDisplay v a) x -> UpdateTypeDisplay v a)
-> Generic (UpdateTypeDisplay v a)
forall x. Rep (UpdateTypeDisplay v a) x -> UpdateTypeDisplay v a
forall x. UpdateTypeDisplay v a -> Rep (UpdateTypeDisplay v a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v a x.
Rep (UpdateTypeDisplay v a) x -> UpdateTypeDisplay v a
forall v a x.
UpdateTypeDisplay v a -> Rep (UpdateTypeDisplay v a) x
$cfrom :: forall v a x.
UpdateTypeDisplay v a -> Rep (UpdateTypeDisplay v a) x
from :: forall x. UpdateTypeDisplay v a -> Rep (UpdateTypeDisplay v a) x
$cto :: forall v a x.
Rep (UpdateTypeDisplay v a) x -> UpdateTypeDisplay v a
to :: forall x. Rep (UpdateTypeDisplay v a) x -> UpdateTypeDisplay v a
Generic, Int -> UpdateTypeDisplay v a -> ShowS
[UpdateTypeDisplay v a] -> ShowS
UpdateTypeDisplay v a -> String
(Int -> UpdateTypeDisplay v a -> ShowS)
-> (UpdateTypeDisplay v a -> String)
-> ([UpdateTypeDisplay v a] -> ShowS)
-> Show (UpdateTypeDisplay v a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall v a.
(Show a, Show v) =>
Int -> UpdateTypeDisplay v a -> ShowS
forall v a. (Show a, Show v) => [UpdateTypeDisplay v a] -> ShowS
forall v a. (Show a, Show v) => UpdateTypeDisplay v a -> String
$cshowsPrec :: forall v a.
(Show a, Show v) =>
Int -> UpdateTypeDisplay v a -> ShowS
showsPrec :: Int -> UpdateTypeDisplay v a -> ShowS
$cshow :: forall v a. (Show a, Show v) => UpdateTypeDisplay v a -> String
show :: UpdateTypeDisplay v a -> String
$cshowList :: forall v a. (Show a, Show v) => [UpdateTypeDisplay v a] -> ShowS
showList :: [UpdateTypeDisplay v a] -> ShowS
Show)

instance Eq (UpdateTypeDisplay v a) where
  UpdateTypeDisplay v a
u0 == :: UpdateTypeDisplay v a -> UpdateTypeDisplay v a -> Bool
== UpdateTypeDisplay v a
u1 = (UpdateTypeDisplay v a
u0 UpdateTypeDisplay v a
-> Getting
     (First (TypeDisplay v a)) (UpdateTypeDisplay v a) (TypeDisplay v a)
-> Maybe (TypeDisplay v a)
forall s a. s -> Getting (First a) s a -> Maybe a
^? ([TypeDisplay v a]
 -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
-> UpdateTypeDisplay v a
-> Const (First (TypeDisplay v a)) (UpdateTypeDisplay v a)
#new (([TypeDisplay v a]
  -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
 -> UpdateTypeDisplay v a
 -> Const (First (TypeDisplay v a)) (UpdateTypeDisplay v a))
-> ((TypeDisplay v a
     -> Const (First (TypeDisplay v a)) (TypeDisplay v a))
    -> [TypeDisplay v a]
    -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
-> Getting
     (First (TypeDisplay v a)) (UpdateTypeDisplay v a) (TypeDisplay v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TypeDisplay v a
 -> Const (First (TypeDisplay v a)) (TypeDisplay v a))
-> [TypeDisplay v a]
-> Const (First (TypeDisplay v a)) [TypeDisplay v a]
forall s a. Cons s s a a => Traversal' s a
Traversal' [TypeDisplay v a] (TypeDisplay v a)
_head) Maybe (TypeDisplay v a) -> Maybe (TypeDisplay v a) -> Bool
forall a. Eq a => a -> a -> Bool
== (UpdateTypeDisplay v a
u1 UpdateTypeDisplay v a
-> Getting
     (First (TypeDisplay v a)) (UpdateTypeDisplay v a) (TypeDisplay v a)
-> Maybe (TypeDisplay v a)
forall s a. s -> Getting (First a) s a -> Maybe a
^? ([TypeDisplay v a]
 -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
-> UpdateTypeDisplay v a
-> Const (First (TypeDisplay v a)) (UpdateTypeDisplay v a)
#new (([TypeDisplay v a]
  -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
 -> UpdateTypeDisplay v a
 -> Const (First (TypeDisplay v a)) (UpdateTypeDisplay v a))
-> ((TypeDisplay v a
     -> Const (First (TypeDisplay v a)) (TypeDisplay v a))
    -> [TypeDisplay v a]
    -> Const (First (TypeDisplay v a)) [TypeDisplay v a])
-> Getting
     (First (TypeDisplay v a)) (UpdateTypeDisplay v a) (TypeDisplay v a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TypeDisplay v a
 -> Const (First (TypeDisplay v a)) (TypeDisplay v a))
-> [TypeDisplay v a]
-> Const (First (TypeDisplay v a)) [TypeDisplay v a]
forall s a. Cons s s a a => Traversal' s a
Traversal' [TypeDisplay v a] (TypeDisplay v a)
_head)

instance Ord (UpdateTypeDisplay v a) where
  compare :: UpdateTypeDisplay v a -> UpdateTypeDisplay v a -> Ordering
compare UpdateTypeDisplay v a
u0 UpdateTypeDisplay v a
u1 =
    case (UpdateTypeDisplay v a
u0 UpdateTypeDisplay v a
-> Getting
     [TypeDisplay v a] (UpdateTypeDisplay v a) [TypeDisplay v a]
-> [TypeDisplay v a]
forall s a. s -> Getting a s a -> a
^. Getting [TypeDisplay v a] (UpdateTypeDisplay v a) [TypeDisplay v a]
#new, UpdateTypeDisplay v a
u1 UpdateTypeDisplay v a
-> Getting
     [TypeDisplay v a] (UpdateTypeDisplay v a) [TypeDisplay v a]
-> [TypeDisplay v a]
forall s a. s -> Getting a s a -> a
^. Getting [TypeDisplay v a] (UpdateTypeDisplay v a) [TypeDisplay v a]
#new) of
      (TypeDisplay v a
t0 : [TypeDisplay v a]
_, TypeDisplay v a
t1 : [TypeDisplay v a]
_) -> TypeDisplay v a -> TypeDisplay v a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare TypeDisplay v a
t0 TypeDisplay v a
t1
      ([TypeDisplay v a]
ts0, [TypeDisplay v a]
ts1) -> Bool -> Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ([TypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TypeDisplay v a]
ts0) ([TypeDisplay v a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [TypeDisplay v a]
ts1)

type RenameTermDisplay v a = (Referent, Maybe (Type v a), Set (HashQualified Name), Set (HashQualified Name))

type RenameTypeDisplay v a = (Reference, Maybe (DeclOrBuiltin v a), Set (HashQualified Name), Set (HashQualified Name))

type PatchDisplay = (Name, P.PatchDiff)

toOutput ::
  forall m v a.
  (Monad m) =>
  (Referent -> m (Maybe (Type v a))) ->
  (Reference -> m (Maybe (DeclOrBuiltin v a))) ->
  Int ->
  Names ->
  Names ->
  BranchDiff.BranchDiff ->
  m (BranchDiffOutput v a)
toOutput :: forall (m :: * -> *) v a.
Monad m =>
(Referent' (Reference' Text Hash) -> m (Maybe (Type v a)))
-> (Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a)))
-> Int
-> Names
-> Names
-> BranchDiff
-> m (BranchDiffOutput v a)
toOutput
  Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf
  Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin
  Int
hqLen
  Names
names1
  Names
names2
  (BranchDiff DiffSlice (Referent' (Reference' Text Hash))
termsDiff DiffSlice (Reference' Text Hash)
typesDiff Map Name (DiffType PatchDiff)
patchesDiff) = do
    let isSimpleUpdate, isNewConflict, isResolvedConflict :: (Eq r) => (Set r, Set r) -> Bool
        isSimpleUpdate :: forall r. Eq r => (Set r, Set r) -> Bool
isSimpleUpdate (Set r
old, Set r
new) = Set r -> Int
forall a. Set a -> Int
Set.size Set r
old Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 Bool -> Bool -> Bool
&& Set r -> Int
forall a. Set a -> Int
Set.size Set r
new Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1
        isNewConflict :: forall r. Eq r => (Set r, Set r) -> Bool
isNewConflict (Set r
_old, Set r
new) = Set r -> Int
forall a. Set a -> Int
Set.size Set r
new Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 -- should already be the case that old /= new
        isResolvedConflict :: forall r. Eq r => (Set r, Set r) -> Bool
isResolvedConflict (Set r
old, Set r
new) = Set r -> Int
forall a. Set a -> Int
Set.size Set r
old Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
&& Set r -> Int
forall a. Set a -> Int
Set.size Set r
new Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1

    ( [UpdateTypeDisplay v a]
updatedTypes :: [UpdateTypeDisplay v a],
      [UpdateTypeDisplay v a]
newTypeConflicts :: [UpdateTypeDisplay v a],
      [UpdateTypeDisplay v a]
resolvedTypeConflicts :: [UpdateTypeDisplay v a]
      ) <-
      let -- things where what the name pointed to changed
          Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
nsUpdates :: Map Name (Set Reference, Set Reference) =
            DiffSlice (Reference' Text Hash)
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
forall r. Ord r => DiffSlice r -> Map Name (Set r, Set r)
BranchDiff.namespaceUpdates DiffSlice (Reference' Text Hash)
typesDiff
          loadOld :: Bool -> Name -> Reference -> m (SimpleTypeDisplay v a)
          loadOld :: Bool -> Name -> Reference' Text Hash -> m (SimpleTypeDisplay v a)
loadOld Bool
forceHQ Name
n Reference' Text Hash
r_old =
            (,,)
              (HashQualified Name
 -> Reference' Text Hash
 -> Maybe (DeclOrBuiltin v a)
 -> SimpleTypeDisplay v a)
-> m (HashQualified Name)
-> m (Reference' Text Hash
      -> Maybe (DeclOrBuiltin v a) -> SimpleTypeDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashQualified Name -> m (HashQualified Name)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                ( if Bool
forceHQ
                    then Int -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName' Int
hqLen Name
n Reference' Text Hash
r_old
                    else Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names1 Name
n Reference' Text Hash
r_old
                )
              m (Reference' Text Hash
   -> Maybe (DeclOrBuiltin v a) -> SimpleTypeDisplay v a)
-> m (Reference' Text Hash)
-> m (Maybe (DeclOrBuiltin v a) -> SimpleTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reference' Text Hash -> m (Reference' Text Hash)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Reference' Text Hash
r_old
              m (Maybe (DeclOrBuiltin v a) -> SimpleTypeDisplay v a)
-> m (Maybe (DeclOrBuiltin v a)) -> m (SimpleTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin Reference' Text Hash
r_old
          loadNew :: Bool -> Name -> Reference -> m (TypeDisplay v a)
          loadNew :: Bool -> Name -> Reference' Text Hash -> m (TypeDisplay v a)
loadNew Bool
forceHQ Name
n Reference' Text Hash
r_new = do
            Maybe (DeclOrBuiltin v a)
decl <- Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin Reference' Text Hash
r_new
            pure
              TypeDisplay
                { $sel:name:TypeDisplay :: HashQualified Name
name =
                    if Bool
forceHQ
                      then Int -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName' Int
hqLen Name
n Reference' Text Hash
r_new
                      else Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names2 Name
n Reference' Text Hash
r_new,
                  $sel:ref:TypeDisplay :: Reference' Text Hash
ref = Reference' Text Hash
r_new,
                  Maybe (DeclOrBuiltin v a)
$sel:decl:TypeDisplay :: Maybe (DeclOrBuiltin v a)
decl :: Maybe (DeclOrBuiltin v a)
decl
                }
          loadEntry :: (Name, (Set Reference, Set Reference)) -> m (UpdateTypeDisplay v a)
          loadEntry :: (Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))
-> m (UpdateTypeDisplay v a)
loadEntry (Name
n, (Set (Reference' Text Hash) -> [Reference' Text Hash]
forall a. Set a -> [a]
Set.toList -> [Reference' Text Hash
rold], Set (Reference' Text Hash) -> [Reference' Text Hash]
forall a. Set a -> [a]
Set.toList -> [Reference' Text Hash
rnew]))
            | Reference' Text Hash
rold Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
rnew = do
                [TypeDisplay v a]
new <- [Reference' Text Hash]
-> (Reference' Text Hash -> m (TypeDisplay v a))
-> m [TypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [Reference' Text Hash
rnew] (Bool -> Name -> Reference' Text Hash -> m (TypeDisplay v a)
loadNew Bool
False Name
n)
                pure
                  UpdateTypeDisplay
                    { $sel:old:UpdateTypeDisplay :: Maybe [SimpleTypeDisplay v a]
old = Maybe [SimpleTypeDisplay v a]
forall a. Maybe a
Nothing,
                      [TypeDisplay v a]
$sel:new:UpdateTypeDisplay :: [TypeDisplay v a]
new :: [TypeDisplay v a]
new
                    }
          loadEntry (Name
n, (Set (Reference' Text Hash)
rs_old, Set (Reference' Text Hash)
rs_new)) = do
            let forceHQ :: Bool
forceHQ = Set (Reference' Text Hash) -> Int
forall a. Set a -> Int
Set.size Set (Reference' Text Hash)
rs_old Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
|| Set (Reference' Text Hash) -> Int
forall a. Set a -> Int
Set.size Set (Reference' Text Hash)
rs_new Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1
            Maybe [SimpleTypeDisplay v a]
old <- [SimpleTypeDisplay v a] -> Maybe [SimpleTypeDisplay v a]
forall a. a -> Maybe a
Just ([SimpleTypeDisplay v a] -> Maybe [SimpleTypeDisplay v a])
-> m [SimpleTypeDisplay v a] -> m (Maybe [SimpleTypeDisplay v a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Reference' Text Hash]
-> (Reference' Text Hash -> m (SimpleTypeDisplay v a))
-> m [SimpleTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Set (Reference' Text Hash) -> [Reference' Text Hash]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set (Reference' Text Hash)
rs_old) (Bool -> Name -> Reference' Text Hash -> m (SimpleTypeDisplay v a)
loadOld Bool
forceHQ Name
n)
            [TypeDisplay v a]
new <- [Reference' Text Hash]
-> (Reference' Text Hash -> m (TypeDisplay v a))
-> m [TypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Set (Reference' Text Hash) -> [Reference' Text Hash]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set (Reference' Text Hash)
rs_new) (Bool -> Name -> Reference' Text Hash -> m (TypeDisplay v a)
loadNew Bool
forceHQ Name
n)
            pure UpdateTypeDisplay {Maybe [SimpleTypeDisplay v a]
$sel:old:UpdateTypeDisplay :: Maybe [SimpleTypeDisplay v a]
old :: Maybe [SimpleTypeDisplay v a]
old, [TypeDisplay v a]
$sel:new:UpdateTypeDisplay :: [TypeDisplay v a]
new :: [TypeDisplay v a]
new}
       in ([UpdateTypeDisplay v a]
 -> [UpdateTypeDisplay v a]
 -> [UpdateTypeDisplay v a]
 -> ([UpdateTypeDisplay v a], [UpdateTypeDisplay v a],
     [UpdateTypeDisplay v a]))
-> m [UpdateTypeDisplay v a]
-> m [UpdateTypeDisplay v a]
-> m [UpdateTypeDisplay v a]
-> m ([UpdateTypeDisplay v a], [UpdateTypeDisplay v a],
      [UpdateTypeDisplay v a])
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
            (,,)
            ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a])
-> m [UpdateTypeDisplay v a] -> m [UpdateTypeDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
-> ((Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))
    -> m (UpdateTypeDisplay v a))
-> m [UpdateTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
 -> [(Name,
      (Set (Reference' Text Hash), Set (Reference' Text Hash)))])
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall a b. (a -> b) -> a -> b
$ ((Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool)
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isSimpleUpdate Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
nsUpdates) (Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))
-> m (UpdateTypeDisplay v a)
loadEntry)
            ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a])
-> m [UpdateTypeDisplay v a] -> m [UpdateTypeDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
-> ((Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))
    -> m (UpdateTypeDisplay v a))
-> m [UpdateTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
 -> [(Name,
      (Set (Reference' Text Hash), Set (Reference' Text Hash)))])
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall a b. (a -> b) -> a -> b
$ ((Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool)
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isNewConflict Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
nsUpdates) (Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))
-> m (UpdateTypeDisplay v a)
loadEntry)
            ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTypeDisplay v a] -> [UpdateTypeDisplay v a])
-> m [UpdateTypeDisplay v a] -> m [UpdateTypeDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
-> ((Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))
    -> m (UpdateTypeDisplay v a))
-> m [UpdateTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
 -> [(Name,
      (Set (Reference' Text Hash), Set (Reference' Text Hash)))])
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> [(Name,
     (Set (Reference' Text Hash), Set (Reference' Text Hash)))]
forall a b. (a -> b) -> a -> b
$ ((Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool)
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
-> Map
     Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Reference' Text Hash), Set (Reference' Text Hash)) -> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isResolvedConflict Map Name (Set (Reference' Text Hash), Set (Reference' Text Hash))
nsUpdates) (Name, (Set (Reference' Text Hash), Set (Reference' Text Hash)))
-> m (UpdateTypeDisplay v a)
loadEntry)

    ( [UpdateTermDisplay v a]
updatedTerms :: [UpdateTermDisplay v a],
      [UpdateTermDisplay v a]
newTermConflicts :: [UpdateTermDisplay v a],
      [UpdateTermDisplay v a]
resolvedTermConflicts :: [UpdateTermDisplay v a]
      ) <-
      let -- things where what the name pointed to changed
          nsUpdates :: Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
nsUpdates = DiffSlice (Referent' (Reference' Text Hash))
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
forall r. Ord r => DiffSlice r -> Map Name (Set r, Set r)
BranchDiff.namespaceUpdates DiffSlice (Referent' (Reference' Text Hash))
termsDiff
          loadOld :: Bool
-> Name
-> Referent' (Reference' Text Hash)
-> m (HashQualified Name, Referent' (Reference' Text Hash),
      Maybe (Type v a))
loadOld Bool
forceHQ Name
n Referent' (Reference' Text Hash)
r_old =
            (,,)
              (HashQualified Name
 -> Referent' (Reference' Text Hash)
 -> Maybe (Type v a)
 -> (HashQualified Name, Referent' (Reference' Text Hash),
     Maybe (Type v a)))
-> m (HashQualified Name)
-> m (Referent' (Reference' Text Hash)
      -> Maybe (Type v a)
      -> (HashQualified Name, Referent' (Reference' Text Hash),
          Maybe (Type v a)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashQualified Name -> m (HashQualified Name)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                ( if Bool
forceHQ
                    then Int
-> Name -> Referent' (Reference' Text Hash) -> HashQualified Name
Names.hqTermName' Int
hqLen Name
n Referent' (Reference' Text Hash)
r_old
                    else Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names1 Name
n Referent' (Reference' Text Hash)
r_old
                )
              m (Referent' (Reference' Text Hash)
   -> Maybe (Type v a)
   -> (HashQualified Name, Referent' (Reference' Text Hash),
       Maybe (Type v a)))
-> m (Referent' (Reference' Text Hash))
-> m (Maybe (Type v a)
      -> (HashQualified Name, Referent' (Reference' Text Hash),
          Maybe (Type v a)))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Referent' (Reference' Text Hash)
-> m (Referent' (Reference' Text Hash))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Referent' (Reference' Text Hash)
r_old
              m (Maybe (Type v a)
   -> (HashQualified Name, Referent' (Reference' Text Hash),
       Maybe (Type v a)))
-> m (Maybe (Type v a))
-> m (HashQualified Name, Referent' (Reference' Text Hash),
      Maybe (Type v a))
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf Referent' (Reference' Text Hash)
r_old
          loadNew :: Bool -> Name -> Referent -> m (TermDisplay v a)
          loadNew :: Bool
-> Name -> Referent' (Reference' Text Hash) -> m (TermDisplay v a)
loadNew Bool
forceHQ Name
n Referent' (Reference' Text Hash)
r_new = do
            Maybe (Type v a)
type_ <- Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf Referent' (Reference' Text Hash)
r_new
            pure
              TermDisplay
                { $sel:name:TermDisplay :: HashQualified Name
name =
                    if Bool
forceHQ
                      then Int
-> Name -> Referent' (Reference' Text Hash) -> HashQualified Name
Names.hqTermName' Int
hqLen Name
n Referent' (Reference' Text Hash)
r_new
                      else Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names2 Name
n Referent' (Reference' Text Hash)
r_new,
                  $sel:ref:TermDisplay :: Referent' (Reference' Text Hash)
ref = Referent' (Reference' Text Hash)
r_new,
                  Maybe (Type v a)
$sel:type_:TermDisplay :: Maybe (Type v a)
type_ :: Maybe (Type v a)
type_
                }
          loadEntry :: (Name, (Set Referent, Set Referent)) -> m (UpdateTermDisplay v a)
          loadEntry :: (Name,
 (Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash))))
-> m (UpdateTermDisplay v a)
loadEntry (Name
n, (Set (Referent' (Reference' Text Hash))
rs_old, Set (Referent' (Reference' Text Hash))
rs_new))
            -- if the references haven't changed, it's code for: only the metadata has changed
            -- and we can ignore the old references in the output.
            | Set (Referent' (Reference' Text Hash))
rs_old Set (Referent' (Reference' Text Hash))
-> Set (Referent' (Reference' Text Hash)) -> Bool
forall a. Eq a => a -> a -> Bool
== Set (Referent' (Reference' Text Hash))
rs_new = do
                [TermDisplay v a]
new <- [Referent' (Reference' Text Hash)]
-> (Referent' (Reference' Text Hash) -> m (TermDisplay v a))
-> m [TermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Set (Referent' (Reference' Text Hash))
-> [Referent' (Reference' Text Hash)]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set (Referent' (Reference' Text Hash))
rs_new) (Bool
-> Name -> Referent' (Reference' Text Hash) -> m (TermDisplay v a)
loadNew Bool
False Name
n)
                pure
                  UpdateTermDisplay
                    { $sel:old:UpdateTermDisplay :: Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
old = Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
forall a. Maybe a
Nothing,
                      [TermDisplay v a]
$sel:new:UpdateTermDisplay :: [TermDisplay v a]
new :: [TermDisplay v a]
new
                    }
            | Bool
otherwise = do
                let forceHQ :: Bool
forceHQ = Set (Referent' (Reference' Text Hash)) -> Int
forall a. Set a -> Int
Set.size Set (Referent' (Reference' Text Hash))
rs_old Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 Bool -> Bool -> Bool
|| Set (Referent' (Reference' Text Hash)) -> Int
forall a. Set a -> Int
Set.size Set (Referent' (Reference' Text Hash))
rs_new Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1
                Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
old <- [(HashQualified Name, Referent' (Reference' Text Hash),
  Maybe (Type v a))]
-> Maybe
     [(HashQualified Name, Referent' (Reference' Text Hash),
       Maybe (Type v a))]
forall a. a -> Maybe a
Just ([(HashQualified Name, Referent' (Reference' Text Hash),
   Maybe (Type v a))]
 -> Maybe
      [(HashQualified Name, Referent' (Reference' Text Hash),
        Maybe (Type v a))])
-> m [(HashQualified Name, Referent' (Reference' Text Hash),
       Maybe (Type v a))]
-> m (Maybe
        [(HashQualified Name, Referent' (Reference' Text Hash),
          Maybe (Type v a))])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Referent' (Reference' Text Hash)]
-> (Referent' (Reference' Text Hash)
    -> m (HashQualified Name, Referent' (Reference' Text Hash),
          Maybe (Type v a)))
-> m [(HashQualified Name, Referent' (Reference' Text Hash),
       Maybe (Type v a))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Set (Referent' (Reference' Text Hash))
-> [Referent' (Reference' Text Hash)]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set (Referent' (Reference' Text Hash))
rs_old) (Bool
-> Name
-> Referent' (Reference' Text Hash)
-> m (HashQualified Name, Referent' (Reference' Text Hash),
      Maybe (Type v a))
loadOld Bool
forceHQ Name
n)
                [TermDisplay v a]
new <- [Referent' (Reference' Text Hash)]
-> (Referent' (Reference' Text Hash) -> m (TermDisplay v a))
-> m [TermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Set (Referent' (Reference' Text Hash))
-> [Referent' (Reference' Text Hash)]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList Set (Referent' (Reference' Text Hash))
rs_new) (Bool
-> Name -> Referent' (Reference' Text Hash) -> m (TermDisplay v a)
loadNew Bool
forceHQ Name
n)
                pure UpdateTermDisplay {Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
$sel:old:UpdateTermDisplay :: Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
old :: Maybe
  [(HashQualified Name, Referent' (Reference' Text Hash),
    Maybe (Type v a))]
old, [TermDisplay v a]
$sel:new:UpdateTermDisplay :: [TermDisplay v a]
new :: [TermDisplay v a]
new}
       in ([UpdateTermDisplay v a]
 -> [UpdateTermDisplay v a]
 -> [UpdateTermDisplay v a]
 -> ([UpdateTermDisplay v a], [UpdateTermDisplay v a],
     [UpdateTermDisplay v a]))
-> m [UpdateTermDisplay v a]
-> m [UpdateTermDisplay v a]
-> m [UpdateTermDisplay v a]
-> m ([UpdateTermDisplay v a], [UpdateTermDisplay v a],
      [UpdateTermDisplay v a])
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3
            (,,)
            -- this is sorting the Update section back into alphabetical Name order
            -- after calling loadEntry on the two halves.
            ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a])
-> m [UpdateTermDisplay v a] -> m [UpdateTermDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name,
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash))))]
-> ((Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))
    -> m (UpdateTermDisplay v a))
-> m [UpdateTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map
   Name
   (Set (Referent' (Reference' Text Hash)),
    Set (Referent' (Reference' Text Hash)))
 -> [(Name,
      (Set (Referent' (Reference' Text Hash)),
       Set (Referent' (Reference' Text Hash))))])
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall a b. (a -> b) -> a -> b
$ ((Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash)))
 -> Bool)
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Referent' (Reference' Text Hash)),
 Set (Referent' (Reference' Text Hash)))
-> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isSimpleUpdate Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
nsUpdates) (Name,
 (Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash))))
-> m (UpdateTermDisplay v a)
loadEntry)
            ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a])
-> m [UpdateTermDisplay v a] -> m [UpdateTermDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name,
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash))))]
-> ((Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))
    -> m (UpdateTermDisplay v a))
-> m [UpdateTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map
   Name
   (Set (Referent' (Reference' Text Hash)),
    Set (Referent' (Reference' Text Hash)))
 -> [(Name,
      (Set (Referent' (Reference' Text Hash)),
       Set (Referent' (Reference' Text Hash))))])
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall a b. (a -> b) -> a -> b
$ ((Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash)))
 -> Bool)
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Referent' (Reference' Text Hash)),
 Set (Referent' (Reference' Text Hash)))
-> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isNewConflict Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
nsUpdates) (Name,
 (Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash))))
-> m (UpdateTermDisplay v a)
loadEntry)
            ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a]
forall a. Ord a => [a] -> [a]
List.sort ([UpdateTermDisplay v a] -> [UpdateTermDisplay v a])
-> m [UpdateTermDisplay v a] -> m [UpdateTermDisplay v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Name,
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash))))]
-> ((Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))
    -> m (UpdateTermDisplay v a))
-> m [UpdateTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map
   Name
   (Set (Referent' (Reference' Text Hash)),
    Set (Referent' (Reference' Text Hash)))
 -> [(Name,
      (Set (Referent' (Reference' Text Hash)),
       Set (Referent' (Reference' Text Hash))))])
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> [(Name,
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash))))]
forall a b. (a -> b) -> a -> b
$ ((Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash)))
 -> Bool)
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
-> Map
     Name
     (Set (Referent' (Reference' Text Hash)),
      Set (Referent' (Reference' Text Hash)))
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Set (Referent' (Reference' Text Hash)),
 Set (Referent' (Reference' Text Hash)))
-> Bool
forall r. Eq r => (Set r, Set r) -> Bool
isResolvedConflict Map
  Name
  (Set (Referent' (Reference' Text Hash)),
   Set (Referent' (Reference' Text Hash)))
nsUpdates) (Name,
 (Set (Referent' (Reference' Text Hash)),
  Set (Referent' (Reference' Text Hash))))
-> m (UpdateTermDisplay v a)
loadEntry)

    let [PatchDisplay]
updatedPatches :: [PatchDisplay] =
          [(Name
name, PatchDiff
diff) | (Name
name, BranchDiff.Modify PatchDiff
diff) <- Map Name (DiffType PatchDiff) -> [(Name, DiffType PatchDiff)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Name (DiffType PatchDiff)
patchesDiff]

    [AddedTypeDisplay v a]
addedTypes :: [AddedTypeDisplay v a] <- do
      let [(Reference' Text Hash, Set Name)]
typeAdds :: [(Reference, Set Name)] =
            ((Reference' Text Hash, Set Name) -> Set Name)
-> [(Reference' Text Hash, Set Name)]
-> [(Reference' Text Hash, Set Name)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn
              (Reference' Text Hash, Set Name) -> Set Name
forall a b. (a, b) -> b
snd
              (Map (Reference' Text Hash) (Set Name)
-> [(Reference' Text Hash, Set Name)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (Reference' Text Hash) (Set Name)
 -> [(Reference' Text Hash, Set Name)])
-> (DiffSlice (Reference' Text Hash)
    -> Map (Reference' Text Hash) (Set Name))
-> DiffSlice (Reference' Text Hash)
-> [(Reference' Text Hash, Set Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relation (Reference' Text Hash) Name
-> Map (Reference' Text Hash) (Set Name)
forall a b. Relation a b -> Map a (Set b)
R.toMultimap (Relation (Reference' Text Hash) Name
 -> Map (Reference' Text Hash) (Set Name))
-> (DiffSlice (Reference' Text Hash)
    -> Relation (Reference' Text Hash) Name)
-> DiffSlice (Reference' Text Hash)
-> Map (Reference' Text Hash) (Set Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffSlice (Reference' Text Hash)
-> Relation (Reference' Text Hash) Name
forall r. DiffSlice r -> Relation r Name
BranchDiff.talladds (DiffSlice (Reference' Text Hash)
 -> [(Reference' Text Hash, Set Name)])
-> DiffSlice (Reference' Text Hash)
-> [(Reference' Text Hash, Set Name)]
forall a b. (a -> b) -> a -> b
$ DiffSlice (Reference' Text Hash)
typesDiff)
      [(Reference' Text Hash, Set Name)]
-> ((Reference' Text Hash, Set Name) -> m (AddedTypeDisplay v a))
-> m [AddedTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [(Reference' Text Hash, Set Name)]
typeAdds \(Reference' Text Hash
r, Set Name
ns) -> do
        let hqs :: [HashQualified Name]
hqs = (Name -> HashQualified Name) -> [Name] -> [HashQualified Name]
forall a b. (a -> b) -> [a] -> [b]
map (\Name
n -> Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names2 Name
n Reference' Text Hash
r) (Set Name -> [Name]
forall a. Set a -> [a]
Set.toList Set Name
ns)
        ([HashQualified Name]
hqs,Reference' Text Hash
r,) (Maybe (DeclOrBuiltin v a) -> AddedTypeDisplay v a)
-> m (Maybe (DeclOrBuiltin v a)) -> m (AddedTypeDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin Reference' Text Hash
r

    [AddedTermDisplay v a]
addedTerms :: [AddedTermDisplay v a] <- do
      let [(Referent' (Reference' Text Hash), Set Name)]
termAdds :: [(Referent, Set Name)] =
            ((Referent' (Reference' Text Hash), Set Name) -> Set Name)
-> [(Referent' (Reference' Text Hash), Set Name)]
-> [(Referent' (Reference' Text Hash), Set Name)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn
              (Referent' (Reference' Text Hash), Set Name) -> Set Name
forall a b. (a, b) -> b
snd
              (Map (Referent' (Reference' Text Hash)) (Set Name)
-> [(Referent' (Reference' Text Hash), Set Name)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (Referent' (Reference' Text Hash)) (Set Name)
 -> [(Referent' (Reference' Text Hash), Set Name)])
-> (DiffSlice (Referent' (Reference' Text Hash))
    -> Map (Referent' (Reference' Text Hash)) (Set Name))
-> DiffSlice (Referent' (Reference' Text Hash))
-> [(Referent' (Reference' Text Hash), Set Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relation (Referent' (Reference' Text Hash)) Name
-> Map (Referent' (Reference' Text Hash)) (Set Name)
forall a b. Relation a b -> Map a (Set b)
R.toMultimap (Relation (Referent' (Reference' Text Hash)) Name
 -> Map (Referent' (Reference' Text Hash)) (Set Name))
-> (DiffSlice (Referent' (Reference' Text Hash))
    -> Relation (Referent' (Reference' Text Hash)) Name)
-> DiffSlice (Referent' (Reference' Text Hash))
-> Map (Referent' (Reference' Text Hash)) (Set Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffSlice (Referent' (Reference' Text Hash))
-> Relation (Referent' (Reference' Text Hash)) Name
forall r. DiffSlice r -> Relation r Name
BranchDiff.talladds (DiffSlice (Referent' (Reference' Text Hash))
 -> [(Referent' (Reference' Text Hash), Set Name)])
-> DiffSlice (Referent' (Reference' Text Hash))
-> [(Referent' (Reference' Text Hash), Set Name)]
forall a b. (a -> b) -> a -> b
$ DiffSlice (Referent' (Reference' Text Hash))
termsDiff)
      [(Referent' (Reference' Text Hash), Set Name)]
-> ((Referent' (Reference' Text Hash), Set Name)
    -> m (AddedTermDisplay v a))
-> m [AddedTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [(Referent' (Reference' Text Hash), Set Name)]
termAdds \(Referent' (Reference' Text Hash)
r, Set Name
ns) -> do
        let hqs :: [HashQualified Name]
hqs = (Name -> HashQualified Name) -> [Name] -> [HashQualified Name]
forall a b. (a -> b) -> [a] -> [b]
map (\Name
n -> Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names2 Name
n Referent' (Reference' Text Hash)
r) (Set Name -> [Name]
forall a. Set a -> [a]
Set.toList Set Name
ns)
        ([HashQualified Name]
hqs,Referent' (Reference' Text Hash)
r,) (Maybe (Type v a) -> AddedTermDisplay v a)
-> m (Maybe (Type v a)) -> m (AddedTermDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf Referent' (Reference' Text Hash)
r

    let [PatchDisplay]
addedPatches :: [PatchDisplay] =
          [ (Name
name, PatchDiff
diff)
            | (Name
name, BranchDiff.Create PatchDiff
diff) <- Map Name (DiffType PatchDiff) -> [(Name, DiffType PatchDiff)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Name (DiffType PatchDiff)
patchesDiff
          ]

    [AddedTypeDisplay v a]
removedTypes :: [RemovedTypeDisplay v a] <-
      let [(Reference' Text Hash, [Name])]
typeRemoves :: [(Reference, [Name])] =
            ((Reference' Text Hash, [Name]) -> [Name])
-> [(Reference' Text Hash, [Name])]
-> [(Reference' Text Hash, [Name])]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Reference' Text Hash, [Name]) -> [Name]
forall a b. (a, b) -> b
snd ([(Reference' Text Hash, [Name])]
 -> [(Reference' Text Hash, [Name])])
-> [(Reference' Text Hash, [Name])]
-> [(Reference' Text Hash, [Name])]
forall a b. (a -> b) -> a -> b
$
              Map (Reference' Text Hash) [Name]
-> [(Reference' Text Hash, [Name])]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (Reference' Text Hash) [Name]
 -> [(Reference' Text Hash, [Name])])
-> (DiffSlice (Reference' Text Hash)
    -> Map (Reference' Text Hash) [Name])
-> DiffSlice (Reference' Text Hash)
-> [(Reference' Text Hash, [Name])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Name -> [Name])
-> Map (Reference' Text Hash) (Set Name)
-> Map (Reference' Text Hash) [Name]
forall a b.
(a -> b)
-> Map (Reference' Text Hash) a -> Map (Reference' Text Hash) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Set Name -> [Name]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Map (Reference' Text Hash) (Set Name)
 -> Map (Reference' Text Hash) [Name])
-> (DiffSlice (Reference' Text Hash)
    -> Map (Reference' Text Hash) (Set Name))
-> DiffSlice (Reference' Text Hash)
-> Map (Reference' Text Hash) [Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relation (Reference' Text Hash) Name
-> Map (Reference' Text Hash) (Set Name)
forall a b. Relation a b -> Map a (Set b)
R.toMultimap (Relation (Reference' Text Hash) Name
 -> Map (Reference' Text Hash) (Set Name))
-> (DiffSlice (Reference' Text Hash)
    -> Relation (Reference' Text Hash) Name)
-> DiffSlice (Reference' Text Hash)
-> Map (Reference' Text Hash) (Set Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffSlice (Reference' Text Hash)
-> Relation (Reference' Text Hash) Name
forall r. DiffSlice r -> Relation r Name
BranchDiff.tallremoves (DiffSlice (Reference' Text Hash)
 -> [(Reference' Text Hash, [Name])])
-> DiffSlice (Reference' Text Hash)
-> [(Reference' Text Hash, [Name])]
forall a b. (a -> b) -> a -> b
$
                DiffSlice (Reference' Text Hash)
typesDiff
       in [(Reference' Text Hash, [Name])]
-> ((Reference' Text Hash, [Name]) -> m (AddedTypeDisplay v a))
-> m [AddedTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [(Reference' Text Hash, [Name])]
typeRemoves (((Reference' Text Hash, [Name]) -> m (AddedTypeDisplay v a))
 -> m [AddedTypeDisplay v a])
-> ((Reference' Text Hash, [Name]) -> m (AddedTypeDisplay v a))
-> m [AddedTypeDisplay v a]
forall a b. (a -> b) -> a -> b
$ \(Reference' Text Hash
r, [Name]
ns) ->
            (,,)
              ([HashQualified Name]
 -> Reference' Text Hash
 -> Maybe (DeclOrBuiltin v a)
 -> AddedTypeDisplay v a)
-> m [HashQualified Name]
-> m (Reference' Text Hash
      -> Maybe (DeclOrBuiltin v a) -> AddedTypeDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [HashQualified Name] -> m [HashQualified Name]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((\Name
n -> Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names1 Name
n Reference' Text Hash
r) (Name -> HashQualified Name) -> [Name] -> [HashQualified Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Name]
ns)
              m (Reference' Text Hash
   -> Maybe (DeclOrBuiltin v a) -> AddedTypeDisplay v a)
-> m (Reference' Text Hash)
-> m (Maybe (DeclOrBuiltin v a) -> AddedTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reference' Text Hash -> m (Reference' Text Hash)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Reference' Text Hash
r
              m (Maybe (DeclOrBuiltin v a) -> AddedTypeDisplay v a)
-> m (Maybe (DeclOrBuiltin v a)) -> m (AddedTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin Reference' Text Hash
r

    [AddedTermDisplay v a]
removedTerms :: [RemovedTermDisplay v a] <-
      let [(Referent' (Reference' Text Hash), [Name])]
termRemoves :: [(Referent, [Name])] =
            ((Referent' (Reference' Text Hash), [Name]) -> [Name])
-> [(Referent' (Reference' Text Hash), [Name])]
-> [(Referent' (Reference' Text Hash), [Name])]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Referent' (Reference' Text Hash), [Name]) -> [Name]
forall a b. (a, b) -> b
snd ([(Referent' (Reference' Text Hash), [Name])]
 -> [(Referent' (Reference' Text Hash), [Name])])
-> [(Referent' (Reference' Text Hash), [Name])]
-> [(Referent' (Reference' Text Hash), [Name])]
forall a b. (a -> b) -> a -> b
$
              Map (Referent' (Reference' Text Hash)) [Name]
-> [(Referent' (Reference' Text Hash), [Name])]
forall k a. Map k a -> [(k, a)]
Map.toList (Map (Referent' (Reference' Text Hash)) [Name]
 -> [(Referent' (Reference' Text Hash), [Name])])
-> (DiffSlice (Referent' (Reference' Text Hash))
    -> Map (Referent' (Reference' Text Hash)) [Name])
-> DiffSlice (Referent' (Reference' Text Hash))
-> [(Referent' (Reference' Text Hash), [Name])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Set Name -> [Name])
-> Map (Referent' (Reference' Text Hash)) (Set Name)
-> Map (Referent' (Reference' Text Hash)) [Name]
forall a b.
(a -> b)
-> Map (Referent' (Reference' Text Hash)) a
-> Map (Referent' (Reference' Text Hash)) b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Set Name -> [Name]
forall a. Set a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList (Map (Referent' (Reference' Text Hash)) (Set Name)
 -> Map (Referent' (Reference' Text Hash)) [Name])
-> (DiffSlice (Referent' (Reference' Text Hash))
    -> Map (Referent' (Reference' Text Hash)) (Set Name))
-> DiffSlice (Referent' (Reference' Text Hash))
-> Map (Referent' (Reference' Text Hash)) [Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Relation (Referent' (Reference' Text Hash)) Name
-> Map (Referent' (Reference' Text Hash)) (Set Name)
forall a b. Relation a b -> Map a (Set b)
R.toMultimap (Relation (Referent' (Reference' Text Hash)) Name
 -> Map (Referent' (Reference' Text Hash)) (Set Name))
-> (DiffSlice (Referent' (Reference' Text Hash))
    -> Relation (Referent' (Reference' Text Hash)) Name)
-> DiffSlice (Referent' (Reference' Text Hash))
-> Map (Referent' (Reference' Text Hash)) (Set Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffSlice (Referent' (Reference' Text Hash))
-> Relation (Referent' (Reference' Text Hash)) Name
forall r. DiffSlice r -> Relation r Name
BranchDiff.tallremoves (DiffSlice (Referent' (Reference' Text Hash))
 -> [(Referent' (Reference' Text Hash), [Name])])
-> DiffSlice (Referent' (Reference' Text Hash))
-> [(Referent' (Reference' Text Hash), [Name])]
forall a b. (a -> b) -> a -> b
$
                DiffSlice (Referent' (Reference' Text Hash))
termsDiff
       in [(Referent' (Reference' Text Hash), [Name])]
-> ((Referent' (Reference' Text Hash), [Name])
    -> m (AddedTermDisplay v a))
-> m [AddedTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for [(Referent' (Reference' Text Hash), [Name])]
termRemoves (((Referent' (Reference' Text Hash), [Name])
  -> m (AddedTermDisplay v a))
 -> m [AddedTermDisplay v a])
-> ((Referent' (Reference' Text Hash), [Name])
    -> m (AddedTermDisplay v a))
-> m [AddedTermDisplay v a]
forall a b. (a -> b) -> a -> b
$ \(Referent' (Reference' Text Hash)
r, [Name]
ns) ->
            (,,)
              ([HashQualified Name]
 -> Referent' (Reference' Text Hash)
 -> Maybe (Type v a)
 -> AddedTermDisplay v a)
-> m [HashQualified Name]
-> m (Referent' (Reference' Text Hash)
      -> Maybe (Type v a) -> AddedTermDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [HashQualified Name] -> m [HashQualified Name]
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((\Name
n -> Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names1 Name
n Referent' (Reference' Text Hash)
r) (Name -> HashQualified Name) -> [Name] -> [HashQualified Name]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Name]
ns)
              m (Referent' (Reference' Text Hash)
   -> Maybe (Type v a) -> AddedTermDisplay v a)
-> m (Referent' (Reference' Text Hash))
-> m (Maybe (Type v a) -> AddedTermDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Referent' (Reference' Text Hash)
-> m (Referent' (Reference' Text Hash))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Referent' (Reference' Text Hash)
r
              m (Maybe (Type v a) -> AddedTermDisplay v a)
-> m (Maybe (Type v a)) -> m (AddedTermDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf Referent' (Reference' Text Hash)
r

    let [PatchDisplay]
removedPatches :: [PatchDisplay] =
          [ (Name
name, PatchDiff
diff)
            | (Name
name, BranchDiff.Delete PatchDiff
diff) <- Map Name (DiffType PatchDiff) -> [(Name, DiffType PatchDiff)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Name (DiffType PatchDiff)
patchesDiff
          ]

    let renamedTerm :: Map Referent (Set Name, Set Name) -> m [RenameTermDisplay v a]
        renamedTerm :: Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
-> m [RenameTermDisplay v a]
renamedTerm Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
renames =
          [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
-> ((Referent' (Reference' Text Hash), (Set Name, Set Name))
    -> m (RenameTermDisplay v a))
-> m [RenameTermDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (((Referent' (Reference' Text Hash), (Set Name, Set Name))
 -> (Set Name, Set Name))
-> [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
-> [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Referent' (Reference' Text Hash), (Set Name, Set Name))
-> (Set Name, Set Name)
forall a b. (a, b) -> b
snd ([(Referent' (Reference' Text Hash), (Set Name, Set Name))]
 -> [(Referent' (Reference' Text Hash), (Set Name, Set Name))])
-> [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
-> [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
forall a b. (a -> b) -> a -> b
$ Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
-> [(Referent' (Reference' Text Hash), (Set Name, Set Name))]
forall k a. Map k a -> [(k, a)]
Map.toList Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
renames) (((Referent' (Reference' Text Hash), (Set Name, Set Name))
  -> m (RenameTermDisplay v a))
 -> m [RenameTermDisplay v a])
-> ((Referent' (Reference' Text Hash), (Set Name, Set Name))
    -> m (RenameTermDisplay v a))
-> m [RenameTermDisplay v a]
forall a b. (a -> b) -> a -> b
$ \(Referent' (Reference' Text Hash)
r, (Set Name
ol'names, Set Name
new'names)) ->
            (,,,)
              (Referent' (Reference' Text Hash)
 -> Maybe (Type v a)
 -> Set (HashQualified Name)
 -> Set (HashQualified Name)
 -> RenameTermDisplay v a)
-> m (Referent' (Reference' Text Hash))
-> m (Maybe (Type v a)
      -> Set (HashQualified Name)
      -> Set (HashQualified Name)
      -> RenameTermDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Referent' (Reference' Text Hash)
-> m (Referent' (Reference' Text Hash))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Referent' (Reference' Text Hash)
r
              m (Maybe (Type v a)
   -> Set (HashQualified Name)
   -> Set (HashQualified Name)
   -> RenameTermDisplay v a)
-> m (Maybe (Type v a))
-> m (Set (HashQualified Name)
      -> Set (HashQualified Name) -> RenameTermDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Referent' (Reference' Text Hash) -> m (Maybe (Type v a))
typeOf Referent' (Reference' Text Hash)
r
              m (Set (HashQualified Name)
   -> Set (HashQualified Name) -> RenameTermDisplay v a)
-> m (Set (HashQualified Name))
-> m (Set (HashQualified Name) -> RenameTermDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set (HashQualified Name) -> m (Set (HashQualified Name))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
n -> Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names1 Name
n Referent' (Reference' Text Hash)
r) Set Name
ol'names)
              m (Set (HashQualified Name) -> RenameTermDisplay v a)
-> m (Set (HashQualified Name)) -> m (RenameTermDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set (HashQualified Name) -> m (Set (HashQualified Name))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
n -> Int
-> Names
-> Name
-> Referent' (Reference' Text Hash)
-> HashQualified Name
Names.hqTermName Int
hqLen Names
names2 Name
n Referent' (Reference' Text Hash)
r) Set Name
new'names)

    let renamedType :: Map Reference (Set Name, Set Name) -> m [RenameTypeDisplay v a]
        renamedType :: Map (Reference' Text Hash) (Set Name, Set Name)
-> m [RenameTypeDisplay v a]
renamedType Map (Reference' Text Hash) (Set Name, Set Name)
renames =
          [(Reference' Text Hash, (Set Name, Set Name))]
-> ((Reference' Text Hash, (Set Name, Set Name))
    -> m (RenameTypeDisplay v a))
-> m [RenameTypeDisplay v a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
t a -> (a -> f b) -> f (t b)
for (((Reference' Text Hash, (Set Name, Set Name))
 -> (Set Name, Set Name))
-> [(Reference' Text Hash, (Set Name, Set Name))]
-> [(Reference' Text Hash, (Set Name, Set Name))]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (Reference' Text Hash, (Set Name, Set Name))
-> (Set Name, Set Name)
forall a b. (a, b) -> b
snd ([(Reference' Text Hash, (Set Name, Set Name))]
 -> [(Reference' Text Hash, (Set Name, Set Name))])
-> [(Reference' Text Hash, (Set Name, Set Name))]
-> [(Reference' Text Hash, (Set Name, Set Name))]
forall a b. (a -> b) -> a -> b
$ Map (Reference' Text Hash) (Set Name, Set Name)
-> [(Reference' Text Hash, (Set Name, Set Name))]
forall k a. Map k a -> [(k, a)]
Map.toList Map (Reference' Text Hash) (Set Name, Set Name)
renames) (((Reference' Text Hash, (Set Name, Set Name))
  -> m (RenameTypeDisplay v a))
 -> m [RenameTypeDisplay v a])
-> ((Reference' Text Hash, (Set Name, Set Name))
    -> m (RenameTypeDisplay v a))
-> m [RenameTypeDisplay v a]
forall a b. (a -> b) -> a -> b
$ \(Reference' Text Hash
r, (Set Name
ol'names, Set Name
new'names)) ->
            (,,,)
              (Reference' Text Hash
 -> Maybe (DeclOrBuiltin v a)
 -> Set (HashQualified Name)
 -> Set (HashQualified Name)
 -> RenameTypeDisplay v a)
-> m (Reference' Text Hash)
-> m (Maybe (DeclOrBuiltin v a)
      -> Set (HashQualified Name)
      -> Set (HashQualified Name)
      -> RenameTypeDisplay v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Reference' Text Hash -> m (Reference' Text Hash)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Reference' Text Hash
r
              m (Maybe (DeclOrBuiltin v a)
   -> Set (HashQualified Name)
   -> Set (HashQualified Name)
   -> RenameTypeDisplay v a)
-> m (Maybe (DeclOrBuiltin v a))
-> m (Set (HashQualified Name)
      -> Set (HashQualified Name) -> RenameTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Reference' Text Hash -> m (Maybe (DeclOrBuiltin v a))
declOrBuiltin Reference' Text Hash
r
              m (Set (HashQualified Name)
   -> Set (HashQualified Name) -> RenameTypeDisplay v a)
-> m (Set (HashQualified Name))
-> m (Set (HashQualified Name) -> RenameTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set (HashQualified Name) -> m (Set (HashQualified Name))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
n -> Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names1 Name
n Reference' Text Hash
r) Set Name
ol'names)
              m (Set (HashQualified Name) -> RenameTypeDisplay v a)
-> m (Set (HashQualified Name)) -> m (RenameTypeDisplay v a)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Set (HashQualified Name) -> m (Set (HashQualified Name))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
n -> Int -> Names -> Name -> Reference' Text Hash -> HashQualified Name
Names.hqTypeName Int
hqLen Names
names2 Name
n Reference' Text Hash
r) Set Name
new'names)

    [RenameTypeDisplay v a]
renamedTypes :: [RenameTypeDisplay v a] <- Map (Reference' Text Hash) (Set Name, Set Name)
-> m [RenameTypeDisplay v a]
renamedType (DiffSlice (Reference' Text Hash)
-> Map (Reference' Text Hash) (Set Name, Set Name)
forall r. DiffSlice r -> Map r (Set Name, Set Name)
BranchDiff.trenames DiffSlice (Reference' Text Hash)
typesDiff)
    [RenameTermDisplay v a]
renamedTerms :: [RenameTermDisplay v a] <- Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
-> m [RenameTermDisplay v a]
renamedTerm (DiffSlice (Referent' (Reference' Text Hash))
-> Map (Referent' (Reference' Text Hash)) (Set Name, Set Name)
forall r. DiffSlice r -> Map r (Set Name, Set Name)
BranchDiff.trenames DiffSlice (Referent' (Reference' Text Hash))
termsDiff)

    pure $
      BranchDiffOutput
        { [UpdateTypeDisplay v a]
$sel:updatedTypes:BranchDiffOutput :: [UpdateTypeDisplay v a]
updatedTypes :: [UpdateTypeDisplay v a]
updatedTypes,
          [UpdateTermDisplay v a]
$sel:updatedTerms:BranchDiffOutput :: [UpdateTermDisplay v a]
updatedTerms :: [UpdateTermDisplay v a]
updatedTerms,
          [UpdateTypeDisplay v a]
$sel:newTypeConflicts:BranchDiffOutput :: [UpdateTypeDisplay v a]
newTypeConflicts :: [UpdateTypeDisplay v a]
newTypeConflicts,
          [UpdateTermDisplay v a]
$sel:newTermConflicts:BranchDiffOutput :: [UpdateTermDisplay v a]
newTermConflicts :: [UpdateTermDisplay v a]
newTermConflicts,
          [UpdateTypeDisplay v a]
$sel:resolvedTypeConflicts:BranchDiffOutput :: [UpdateTypeDisplay v a]
resolvedTypeConflicts :: [UpdateTypeDisplay v a]
resolvedTypeConflicts,
          [UpdateTermDisplay v a]
$sel:resolvedTermConflicts:BranchDiffOutput :: [UpdateTermDisplay v a]
resolvedTermConflicts :: [UpdateTermDisplay v a]
resolvedTermConflicts,
          [PatchDisplay]
$sel:updatedPatches:BranchDiffOutput :: [PatchDisplay]
updatedPatches :: [PatchDisplay]
updatedPatches,
          [AddedTypeDisplay v a]
$sel:addedTypes:BranchDiffOutput :: [AddedTypeDisplay v a]
addedTypes :: [AddedTypeDisplay v a]
addedTypes,
          [AddedTermDisplay v a]
$sel:addedTerms:BranchDiffOutput :: [AddedTermDisplay v a]
addedTerms :: [AddedTermDisplay v a]
addedTerms,
          [PatchDisplay]
$sel:addedPatches:BranchDiffOutput :: [PatchDisplay]
addedPatches :: [PatchDisplay]
addedPatches,
          [AddedTypeDisplay v a]
$sel:removedTypes:BranchDiffOutput :: [AddedTypeDisplay v a]
removedTypes :: [AddedTypeDisplay v a]
removedTypes,
          [AddedTermDisplay v a]
$sel:removedTerms:BranchDiffOutput :: [AddedTermDisplay v a]
removedTerms :: [AddedTermDisplay v a]
removedTerms,
          [PatchDisplay]
$sel:removedPatches:BranchDiffOutput :: [PatchDisplay]
removedPatches :: [PatchDisplay]
removedPatches,
          [RenameTypeDisplay v a]
$sel:renamedTypes:BranchDiffOutput :: [RenameTypeDisplay v a]
renamedTypes :: [RenameTypeDisplay v a]
renamedTypes,
          [RenameTermDisplay v a]
$sel:renamedTerms:BranchDiffOutput :: [RenameTermDisplay v a]
renamedTerms :: [RenameTermDisplay v a]
renamedTerms
        }