module Unison.PrettyPrintEnv.Names
  ( -- * Namer
    Namer (..),
    alwaysHqNamer,
    hqNamer,
    namer,

    -- * Suffixifier
    Suffixifier,
    dontSuffixify,
    suffixifyByHash,
    suffixifyByHashName,
    suffixifyByName,
    suffixifyByHashWithUnhashedTermsInScope,

    -- * Pretty-print env
    hashQualifyShadowed,
    makePPE,
    makeTermNames,
    makeTypeNames,
  )
where

import Data.Set qualified as Set
import Unison.HashQualifiedPrime qualified as HQ'
import Unison.Name (Name)
import Unison.Name qualified as Name
import Unison.Names (Names)
import Unison.Names qualified as Names
import Unison.Names.ResolvesTo (ResolvesTo (..))
import Unison.NamesWithHistory qualified as Names
import Unison.Prelude
import Unison.PrettyPrintEnv (PrettyPrintEnv (..))
import Unison.Reference (TypeReference)
import Unison.Referent (Referent)
import Unison.Util.Relation (Relation)
import Unison.Util.Relation qualified as Relation

------------------------------------------------------------------------------------------------------------------------
-- Namer

-- | A "namer" associates a set of (possibly hash-qualified) names with a referent / type reference.
data Namer = Namer
  { Namer -> Referent -> Set (HashQualified Name)
nameTerm :: Referent -> Set (HQ'.HashQualified Name),
    Namer -> TypeReference -> Set (HashQualified Name)
nameType :: TypeReference -> Set (HQ'.HashQualified Name)
  }

-- | Make a "namer" out of a collection of names, ignoring conflicted names. That is, if references #foo and #bar are
-- both associated with name "baz", then the returned namer maps #foo too "baz" (not "baz"#foo) and #bar to "baz" (not
-- "baz"#bar).
namer :: Names -> Namer
namer :: Names -> Namer
namer Names
names =
  Namer
    { nameTerm :: Referent -> Set (HashQualified Name)
nameTerm = (Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Name -> HashQualified Name
forall n. n -> HashQualified n
HQ'.fromName (Set Name -> Set (HashQualified Name))
-> (Referent -> Set Name) -> Referent -> Set (HashQualified Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Names -> Referent -> Set Name
Names.namesForReferent Names
names,
      nameType :: TypeReference -> Set (HashQualified Name)
nameType = (Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map Name -> HashQualified Name
forall n. n -> HashQualified n
HQ'.fromName (Set Name -> Set (HashQualified Name))
-> (TypeReference -> Set Name)
-> TypeReference
-> Set (HashQualified Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Names -> TypeReference -> Set Name
Names.namesForReference Names
names
    }

-- | Make a "namer" out of a collection of names, respecting conflicted names. That is, if references #foo and #bar are
-- both associated with name "baz", then the returned namer maps #foo too "baz"#foo and #bar to "baz"#bar, but otherwise
-- if a reference #qux has a single name "qux", then the returned namer maps #qux to "qux" (not "qux"#qux).
hqNamer :: Int -> Names -> Namer
hqNamer :: Int -> Names -> Namer
hqNamer Int
hashLen Names
names =
  Namer
    { nameTerm :: Referent -> Set (HashQualified Name)
nameTerm = \Referent
ref -> Int -> Referent -> Names -> Set (HashQualified Name)
Names.termName Int
hashLen Referent
ref Names
names,
      nameType :: TypeReference -> Set (HashQualified Name)
nameType = \TypeReference
ref -> Int -> TypeReference -> Names -> Set (HashQualified Name)
Names.typeName Int
hashLen TypeReference
ref Names
names
    }

-- | Make a "namer" that hash-qualifies every name, conflicted or not. This suits names that may no longer mean what
-- they say: for instance, a name in the codebase that a Unison file shadows.
alwaysHqNamer :: Int -> Names -> Namer
alwaysHqNamer :: Int -> Names -> Namer
alwaysHqNamer Int
hashLen Names
names =
  Namer
    { nameTerm :: Referent -> Set (HashQualified Name)
nameTerm = \Referent
ref -> (Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
name -> Int -> HashQualified Name -> HashQualified Name
forall n. Int -> HashQualified n -> HashQualified n
HQ'.take Int
hashLen (Name -> Referent -> HashQualified Name
forall n. n -> Referent -> HashQualified n
HQ'.fromNamedReferent Name
name Referent
ref)) (Names -> Referent -> Set Name
Names.namesForReferent Names
names Referent
ref),
      nameType :: TypeReference -> Set (HashQualified Name)
nameType = \TypeReference
ref -> (Name -> HashQualified Name)
-> Set Name -> Set (HashQualified Name)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (\Name
name -> Int -> HashQualified Name -> HashQualified Name
forall n. Int -> HashQualified n -> HashQualified n
HQ'.take Int
hashLen (Name -> TypeReference -> HashQualified Name
forall n. n -> TypeReference -> HashQualified n
HQ'.fromNamedReference Name
name TypeReference
ref)) (Names -> TypeReference -> Set Name
Names.namesForReference Names
names TypeReference
ref)
    }

------------------------------------------------------------------------------------------------------------------------
-- Suffixifier

data Suffixifier = Suffixifier
  { Suffixifier -> Name -> Name
suffixifyTerm :: Name -> Name,
    Suffixifier -> Name -> Name
suffixifyType :: Name -> Name
  }

dontSuffixify :: Suffixifier
dontSuffixify :: Suffixifier
dontSuffixify =
  (Name -> Name) -> (Name -> Name) -> Suffixifier
Suffixifier Name -> Name
forall a. a -> a
id Name -> Name
forall a. a -> a
id

suffixifyByName :: Names -> Suffixifier
suffixifyByName :: Names -> Suffixifier
suffixifyByName Names
names =
  let terms :: Relation Name Referent
terms = Names -> Relation Name Referent
Names.terms Names
names
      types :: Relation Name TypeReference
types = Names -> Relation Name TypeReference
Names.types Names
names
   in Suffixifier
        { suffixifyTerm :: Name -> Name
suffixifyTerm = (Name -> Relation Name Referent -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByName` Relation Name Referent
terms),
          suffixifyType :: Name -> Name
suffixifyType = (Name -> Relation Name TypeReference -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByName` Relation Name TypeReference
types)
        }

suffixifyByHash :: Names -> Suffixifier
suffixifyByHash :: Names -> Suffixifier
suffixifyByHash Names
names =
  let terms :: Relation Name Referent
terms = Names -> Relation Name Referent
Names.terms Names
names
      types :: Relation Name TypeReference
types = Names -> Relation Name TypeReference
Names.types Names
names
   in Suffixifier
        { suffixifyTerm :: Name -> Name
suffixifyTerm = (Name -> Relation Name Referent -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHash` Relation Name Referent
terms),
          suffixifyType :: Name -> Name
suffixifyType = (Name -> Relation Name TypeReference -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHash` Relation Name TypeReference
types)
        }

suffixifyByHashName :: Names -> Suffixifier
suffixifyByHashName :: Names -> Suffixifier
suffixifyByHashName Names
names =
  let terms :: Relation Name Referent
terms = Names -> Relation Name Referent
Names.terms Names
names
      types :: Relation Name TypeReference
types = Names -> Relation Name TypeReference
Names.types Names
names
   in Suffixifier
        { suffixifyTerm :: Name -> Name
suffixifyTerm = (Name -> Relation Name Referent -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHashName` Relation Name Referent
terms),
          suffixifyType :: Name -> Name
suffixifyType = (Name -> Relation Name TypeReference -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHashName` Relation Name TypeReference
types)
        }

suffixifyByHashWithUnhashedTermsInScope :: Set Name -> Names -> Suffixifier
suffixifyByHashWithUnhashedTermsInScope :: Set Name -> Names -> Suffixifier
suffixifyByHashWithUnhashedTermsInScope Set Name
localTermNames Names
namespaceNames =
  Suffixifier
    { suffixifyTerm :: Name -> Name
suffixifyTerm = (Name -> Relation Name (ResolvesTo Referent) -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHash` Relation Name (ResolvesTo Referent)
terms),
      suffixifyType :: Name -> Name
suffixifyType = (Name -> Relation Name TypeReference -> Name
forall r. Ord r => Name -> Relation Name r -> Name
`Name.suffixifyByHash` Relation Name TypeReference
types)
    }
  where
    terms :: Relation Name (ResolvesTo Referent)
    terms :: Relation Name (ResolvesTo Referent)
terms =
      Names -> Relation Name Referent
Names.terms Names
namespaceNames
        Relation Name Referent
-> (Relation Name Referent -> Relation Name Referent)
-> Relation Name Referent
forall a b. a -> (a -> b) -> b
& Set Name -> Relation Name Referent -> Relation Name Referent
forall a b. (Ord a, Ord b) => Set a -> Relation a b -> Relation a b
Relation.subtractDom Set Name
localTermNames
        Relation Name Referent
-> (Relation Name Referent -> Relation Name (ResolvesTo Referent))
-> Relation Name (ResolvesTo Referent)
forall a b. a -> (a -> b) -> b
& (Referent -> ResolvesTo Referent)
-> Relation Name Referent -> Relation Name (ResolvesTo Referent)
forall a b b'.
(Ord a, Ord b, Ord b') =>
(b -> b') -> Relation a b -> Relation a b'
Relation.mapRan Referent -> ResolvesTo Referent
forall ref. ref -> ResolvesTo ref
ResolvesToNamespace
        Relation Name (ResolvesTo Referent)
-> (Relation Name (ResolvesTo Referent)
    -> Relation Name (ResolvesTo Referent))
-> Relation Name (ResolvesTo Referent)
forall a b. a -> (a -> b) -> b
& Relation Name (ResolvesTo Referent)
-> Relation Name (ResolvesTo Referent)
-> Relation Name (ResolvesTo Referent)
forall a b.
(Ord a, Ord b) =>
Relation a b -> Relation a b -> Relation a b
Relation.union ([(Name, ResolvesTo Referent)]
-> Relation Name (ResolvesTo Referent)
forall a b. (Ord a, Ord b) => [(a, b)] -> Relation a b
Relation.fromList ((Name -> (Name, ResolvesTo Referent))
-> [Name] -> [(Name, ResolvesTo Referent)]
forall a b. (a -> b) -> [a] -> [b]
map (\Name
name -> (Name
name, Name -> ResolvesTo Referent
forall ref. Name -> ResolvesTo ref
ResolvesToLocal Name
name)) (Set Name -> [Name]
forall a. Set a -> [a]
Set.toList Set Name
localTermNames)))

    types :: Relation Name TypeReference
    types :: Relation Name TypeReference
types =
      Names -> Relation Name TypeReference
Names.types Names
namespaceNames

------------------------------------------------------------------------------------------------------------------------
-- Pretty-print env

-- | Hash-qualify the names in a pretty-print env that the given names shadow, unless the reference has another name that
-- isn't shadowed. This is a cheap alternative to rebuilding a large pretty-print env with 'Names.shadowing'.
hashQualifyShadowed :: Int -> Names -> PrettyPrintEnv -> PrettyPrintEnv
hashQualifyShadowed :: Int -> Names -> PrettyPrintEnv -> PrettyPrintEnv
hashQualifyShadowed Int
hashLen Names
shadowing PrettyPrintEnv
ppe =
  PrettyPrintEnv
    { termNames :: Referent -> [(HashQualified Name, HashQualified Name)]
termNames = \Referent
ref -> (Name -> Bool)
-> (Name -> HashQualified Name)
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
go (Name -> Relation Name Referent -> Bool
forall a b. Ord a => a -> Relation a b -> Bool
`Relation.memberDom` Names -> Relation Name Referent
Names.terms Names
shadowing) (Name -> Referent -> HashQualified Name
forall n. n -> Referent -> HashQualified n
`HQ'.fromNamedReferent` Referent
ref) (PrettyPrintEnv
-> Referent -> [(HashQualified Name, HashQualified Name)]
termNames PrettyPrintEnv
ppe Referent
ref),
      typeNames :: TypeReference -> [(HashQualified Name, HashQualified Name)]
typeNames = \TypeReference
ref -> (Name -> Bool)
-> (Name -> HashQualified Name)
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
go (Name -> Relation Name TypeReference -> Bool
forall a b. Ord a => a -> Relation a b -> Bool
`Relation.memberDom` Names -> Relation Name TypeReference
Names.types Names
shadowing) (Name -> TypeReference -> HashQualified Name
forall n. n -> TypeReference -> HashQualified n
`HQ'.fromNamedReference` TypeReference
ref) (PrettyPrintEnv
-> TypeReference -> [(HashQualified Name, HashQualified Name)]
typeNames PrettyPrintEnv
ppe TypeReference
ref)
    }
  where
    go ::
      (Name -> Bool) ->
      (Name -> HQ'.HashQualified Name) ->
      [(HQ'.HashQualified Name, HQ'.HashQualified Name)] ->
      [(HQ'.HashQualified Name, HQ'.HashQualified Name)]
    go :: (Name -> Bool)
-> (Name -> HashQualified Name)
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
go Name -> Bool
isShadowed Name -> HashQualified Name
qualify [(HashQualified Name, HashQualified Name)]
names =
      case ((HashQualified Name, HashQualified Name) -> Bool)
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool)
-> ((HashQualified Name, HashQualified Name) -> Bool)
-> (HashQualified Name, HashQualified Name)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Bool
isShadowed (Name -> Bool)
-> ((HashQualified Name, HashQualified Name) -> Name)
-> (HashQualified Name, HashQualified Name)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashQualified Name -> Name
forall n. HashQualified n -> n
HQ'.toName (HashQualified Name -> Name)
-> ((HashQualified Name, HashQualified Name) -> HashQualified Name)
-> (HashQualified Name, HashQualified Name)
-> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HashQualified Name, HashQualified Name) -> HashQualified Name
forall a b. (a, b) -> a
fst) [(HashQualified Name, HashQualified Name)]
names of
        [] -> ((HashQualified Name, HashQualified Name)
 -> (HashQualified Name, HashQualified Name))
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
forall a b. (a -> b) -> [a] -> [b]
map ((HashQualified Name -> HashQualified Name)
-> (HashQualified Name -> HashQualified Name)
-> (HashQualified Name, HashQualified Name)
-> (HashQualified Name, HashQualified Name)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap HashQualified Name -> HashQualified Name
qualify' HashQualified Name -> HashQualified Name
qualify') [(HashQualified Name, HashQualified Name)]
names
        [(HashQualified Name, HashQualified Name)]
unshadowed -> [(HashQualified Name, HashQualified Name)]
unshadowed
      where
        qualify' :: HashQualified Name -> HashQualified Name
qualify' = Int -> HashQualified Name -> HashQualified Name
forall n. Int -> HashQualified n -> HashQualified n
HQ'.take Int
hashLen (HashQualified Name -> HashQualified Name)
-> (HashQualified Name -> HashQualified Name)
-> HashQualified Name
-> HashQualified Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> HashQualified Name
qualify (Name -> HashQualified Name)
-> (HashQualified Name -> Name)
-> HashQualified Name
-> HashQualified Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashQualified Name -> Name
forall n. HashQualified n -> n
HQ'.toName

makePPE :: Namer -> Suffixifier -> PrettyPrintEnv
makePPE :: Namer -> Suffixifier -> PrettyPrintEnv
makePPE Namer
namer Suffixifier
suffixifier =
  PrettyPrintEnv
    { termNames :: Referent -> [(HashQualified Name, HashQualified Name)]
termNames = Namer
-> Suffixifier
-> Referent
-> [(HashQualified Name, HashQualified Name)]
makeTermNames Namer
namer Suffixifier
suffixifier,
      typeNames :: TypeReference -> [(HashQualified Name, HashQualified Name)]
typeNames = Namer
-> Suffixifier
-> TypeReference
-> [(HashQualified Name, HashQualified Name)]
makeTypeNames Namer
namer Suffixifier
suffixifier
    }

makeTermNames :: Namer -> Suffixifier -> Referent -> [(HQ'.HashQualified Name, HQ'.HashQualified Name)]
makeTermNames :: Namer
-> Suffixifier
-> Referent
-> [(HashQualified Name, HashQualified Name)]
makeTermNames Namer {Referent -> Set (HashQualified Name)
nameTerm :: Namer -> Referent -> Set (HashQualified Name)
nameTerm :: Referent -> Set (HashQualified Name)
nameTerm} Suffixifier {Name -> Name
suffixifyTerm :: Suffixifier -> Name -> Name
suffixifyTerm :: Name -> Name
suffixifyTerm} =
  [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
prioritize ([(HashQualified Name, HashQualified Name)]
 -> [(HashQualified Name, HashQualified Name)])
-> (Referent -> [(HashQualified Name, HashQualified Name)])
-> Referent
-> [(HashQualified Name, HashQualified Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HashQualified Name -> (HashQualified Name, HashQualified Name))
-> [HashQualified Name]
-> [(HashQualified Name, HashQualified Name)]
forall a b. (a -> b) -> [a] -> [b]
map (\HashQualified Name
name -> (HashQualified Name
name, Name -> Name
suffixifyTerm (Name -> Name) -> HashQualified Name -> HashQualified Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashQualified Name
name)) ([HashQualified Name]
 -> [(HashQualified Name, HashQualified Name)])
-> (Referent -> [HashQualified Name])
-> Referent
-> [(HashQualified Name, HashQualified Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (HashQualified Name) -> [HashQualified Name]
forall a. Set a -> [a]
Set.toList (Set (HashQualified Name) -> [HashQualified Name])
-> (Referent -> Set (HashQualified Name))
-> Referent
-> [HashQualified Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Referent -> Set (HashQualified Name)
nameTerm

makeTypeNames :: Namer -> Suffixifier -> TypeReference -> [(HQ'.HashQualified Name, HQ'.HashQualified Name)]
makeTypeNames :: Namer
-> Suffixifier
-> TypeReference
-> [(HashQualified Name, HashQualified Name)]
makeTypeNames Namer {TypeReference -> Set (HashQualified Name)
nameType :: Namer -> TypeReference -> Set (HashQualified Name)
nameType :: TypeReference -> Set (HashQualified Name)
nameType} Suffixifier {Name -> Name
suffixifyType :: Suffixifier -> Name -> Name
suffixifyType :: Name -> Name
suffixifyType} =
  [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
prioritize ([(HashQualified Name, HashQualified Name)]
 -> [(HashQualified Name, HashQualified Name)])
-> (TypeReference -> [(HashQualified Name, HashQualified Name)])
-> TypeReference
-> [(HashQualified Name, HashQualified Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (HashQualified Name -> (HashQualified Name, HashQualified Name))
-> [HashQualified Name]
-> [(HashQualified Name, HashQualified Name)]
forall a b. (a -> b) -> [a] -> [b]
map (\HashQualified Name
name -> (HashQualified Name
name, Name -> Name
suffixifyType (Name -> Name) -> HashQualified Name -> HashQualified Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HashQualified Name
name)) ([HashQualified Name]
 -> [(HashQualified Name, HashQualified Name)])
-> (TypeReference -> [HashQualified Name])
-> TypeReference
-> [(HashQualified Name, HashQualified Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set (HashQualified Name) -> [HashQualified Name]
forall a. Set a -> [a]
Set.toList (Set (HashQualified Name) -> [HashQualified Name])
-> (TypeReference -> Set (HashQualified Name))
-> TypeReference
-> [HashQualified Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeReference -> Set (HashQualified Name)
nameType

-- | Sort the names for a given ref by the following factors (in priority order):
--
-- 1. Prefer Relative Names to Absolute Names
-- 2. Prefer names that aren't hash qualified to those that are
-- 3. Prefer names which have fewer segments in their fully-qualified form
-- 4. Prefer names which have fewer segments in their suffixified form (if applicable)
prioritize :: [(HQ'.HashQualified Name, HQ'.HashQualified Name)] -> [(HQ'.HashQualified Name, HQ'.HashQualified Name)]
prioritize :: [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
prioritize =
  ((HashQualified Name, HashQualified Name)
 -> (Bool, Maybe ShortHash, Int, Int))
-> [(HashQualified Name, HashQualified Name)]
-> [(HashQualified Name, HashQualified Name)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn \case
    (HashQualified Name
fqn, HQ'.NameOnly Name
name) -> (Name -> Bool
Name.isAbsolute Name
name, Maybe ShortHash
forall a. Maybe a
Nothing, Name -> Int
Name.countSegments (HashQualified Name -> Name
forall n. HashQualified n -> n
HQ'.toName HashQualified Name
fqn), Name -> Int
Name.countSegments Name
name)
    (HashQualified Name
fqn, HQ'.HashQualified Name
name ShortHash
hash) -> (Name -> Bool
Name.isAbsolute Name
name, ShortHash -> Maybe ShortHash
forall a. a -> Maybe a
Just ShortHash
hash, Name -> Int
Name.countSegments (HashQualified Name -> Name
forall n. HashQualified n -> n
HQ'.toName HashQualified Name
fqn), Name -> Int
Name.countSegments Name
name)