{-| Abstract names carry unique identifiers and stuff.
-}
module Agda.Syntax.Abstract.Name
  ( module Agda.Syntax.Abstract.Name
  , IsNoName(..)
  , FreshNameMode(..)
  ) where

import Prelude hiding (length, null)

import Control.DeepSeq

import Data.Foldable (length)
import Data.Function (on)
import Data.Hashable (Hashable(..))
import qualified Data.List as List
import Data.Maybe
import Data.Map (Map)
import Data.Void

import GHC.Generics (Generic)

import Agda.Syntax.Position
import Agda.Syntax.Common
import Agda.Syntax.Common.Pretty
import Agda.Syntax.Concrete.Name (IsNoName(..), NumHoles(..), NameInScope(..), LensInScope(..), FreshNameMode(..))
import qualified Agda.Syntax.Concrete.Name as C

import Agda.Utils.Functor
import Agda.Utils.Lens
import Agda.Utils.List qualified as List
import Agda.Utils.List1 (List1, pattern (:|), (<|))
import Agda.Utils.List1 qualified as List1
import Agda.Utils.Map1 (Map1)
import Agda.Utils.Map1 qualified as Map1
import Agda.Utils.Maybe ( unionMaybeWith )
import Agda.Utils.Null
import Agda.Utils.Singleton
import Agda.Utils.Size

import qualified Agda.Syntax.Common.Aspect as Asp
import Agda.Utils.Impossible

---------------------------------------------------------------------------
-- * Types
---------------------------------------------------------------------------

-- | A name is a unique identifier and a suggestion for a concrete name. The
--   concrete name contains the source location (if any) of the name. The
--   source location of the binding site is also recorded.
data Name = Name
  { Name -> NameId
_nameId          :: {-# UNPACK #-} !NameId
  , Name -> Name
nameConcrete     :: C.Name  -- ^ The concrete name used for this instance
  , Name -> Name
nameCanonical    :: C.Name  -- ^ The concrete name in the original definition (needed by primShowQName, see #4735)
  , Name -> Range
_nameBindingSite :: Range   -- ^ Range of the name in its /defining/ occurrence.
  , Name -> Fixity'
nameFixity       :: Fixity'
  , Name -> Bool
nameIsRecordName :: Bool
      -- ^ Is this the name of the invisible record variable `self`?
      --   Should not be printed or displayed in the context, see issue #3584.
  }

-- | A name suffix.
data Suffix
  = NoSuffix
  | Suffix !Integer
  deriving (Int -> Suffix -> ShowS
[Suffix] -> ShowS
Suffix -> [Char]
(Int -> Suffix -> ShowS)
-> (Suffix -> [Char]) -> ([Suffix] -> ShowS) -> Show Suffix
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Suffix -> ShowS
showsPrec :: Int -> Suffix -> ShowS
$cshow :: Suffix -> [Char]
show :: Suffix -> [Char]
$cshowList :: [Suffix] -> ShowS
showList :: [Suffix] -> ShowS
Show, Suffix -> Suffix -> Bool
(Suffix -> Suffix -> Bool)
-> (Suffix -> Suffix -> Bool) -> Eq Suffix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Suffix -> Suffix -> Bool
== :: Suffix -> Suffix -> Bool
$c/= :: Suffix -> Suffix -> Bool
/= :: Suffix -> Suffix -> Bool
Eq, Eq Suffix
Eq Suffix =>
(Suffix -> Suffix -> Ordering)
-> (Suffix -> Suffix -> Bool)
-> (Suffix -> Suffix -> Bool)
-> (Suffix -> Suffix -> Bool)
-> (Suffix -> Suffix -> Bool)
-> (Suffix -> Suffix -> Suffix)
-> (Suffix -> Suffix -> Suffix)
-> Ord Suffix
Suffix -> Suffix -> Bool
Suffix -> Suffix -> Ordering
Suffix -> Suffix -> Suffix
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Suffix -> Suffix -> Ordering
compare :: Suffix -> Suffix -> Ordering
$c< :: Suffix -> Suffix -> Bool
< :: Suffix -> Suffix -> Bool
$c<= :: Suffix -> Suffix -> Bool
<= :: Suffix -> Suffix -> Bool
$c> :: Suffix -> Suffix -> Bool
> :: Suffix -> Suffix -> Bool
$c>= :: Suffix -> Suffix -> Bool
>= :: Suffix -> Suffix -> Bool
$cmax :: Suffix -> Suffix -> Suffix
max :: Suffix -> Suffix -> Suffix
$cmin :: Suffix -> Suffix -> Suffix
min :: Suffix -> Suffix -> Suffix
Ord)

-- | Qualified names are non-empty lists of names. Equality on qualified names
--   are just equality on the last name, i.e. the module part is just
--   for show.
--
-- The 'SetRange' instance for qualified names sets all individual
-- ranges (including those of the module prefix) to the given one.
data QName = QName
  { QName -> ModuleName
qnameModule :: ModuleName
  , QName -> Name
qnameName   :: Name
  } deriving ((forall x. QName -> Rep QName x)
-> (forall x. Rep QName x -> QName) -> Generic QName
forall x. Rep QName x -> QName
forall x. QName -> Rep QName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. QName -> Rep QName x
from :: forall x. QName -> Rep QName x
$cto :: forall x. Rep QName x -> QName
to :: forall x. Rep QName x -> QName
Generic)

-- | Something preceeded by a qualified name.
data QNamed a = QNamed
  { forall a. QNamed a -> QName
qname  :: QName
  , forall a. QNamed a -> a
qnamed :: a
  }
  deriving ((forall a b. (a -> b) -> QNamed a -> QNamed b)
-> (forall a b. a -> QNamed b -> QNamed a) -> Functor QNamed
forall a b. a -> QNamed b -> QNamed a
forall a b. (a -> b) -> QNamed a -> QNamed b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> QNamed a -> QNamed b
fmap :: forall a b. (a -> b) -> QNamed a -> QNamed b
$c<$ :: forall a b. a -> QNamed b -> QNamed a
<$ :: forall a b. a -> QNamed b -> QNamed a
Functor, (forall m. Monoid m => QNamed m -> m)
-> (forall m a. Monoid m => (a -> m) -> QNamed a -> m)
-> (forall m a. Monoid m => (a -> m) -> QNamed a -> m)
-> (forall a b. (a -> b -> b) -> b -> QNamed a -> b)
-> (forall a b. (a -> b -> b) -> b -> QNamed a -> b)
-> (forall b a. (b -> a -> b) -> b -> QNamed a -> b)
-> (forall b a. (b -> a -> b) -> b -> QNamed a -> b)
-> (forall a. (a -> a -> a) -> QNamed a -> a)
-> (forall a. (a -> a -> a) -> QNamed a -> a)
-> (forall a. QNamed a -> [a])
-> (forall a. QNamed a -> Bool)
-> (forall a. QNamed a -> Int)
-> (forall a. Eq a => a -> QNamed a -> Bool)
-> (forall a. Ord a => QNamed a -> a)
-> (forall a. Ord a => QNamed a -> a)
-> (forall a. Num a => QNamed a -> a)
-> (forall a. Num a => QNamed a -> a)
-> Foldable QNamed
forall a. Eq a => a -> QNamed a -> Bool
forall a. Num a => QNamed a -> a
forall a. Ord a => QNamed a -> a
forall m. Monoid m => QNamed m -> m
forall a. QNamed a -> Bool
forall a. QNamed a -> Int
forall a. QNamed a -> [a]
forall a. (a -> a -> a) -> QNamed a -> a
forall m a. Monoid m => (a -> m) -> QNamed a -> m
forall b a. (b -> a -> b) -> b -> QNamed a -> b
forall a b. (a -> b -> b) -> b -> QNamed a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => QNamed m -> m
fold :: forall m. Monoid m => QNamed m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> QNamed a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> QNamed a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> QNamed a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> QNamed a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> QNamed a -> b
foldr :: forall a b. (a -> b -> b) -> b -> QNamed a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> QNamed a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> QNamed a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> QNamed a -> b
foldl :: forall b a. (b -> a -> b) -> b -> QNamed a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> QNamed a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> QNamed a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> QNamed a -> a
foldr1 :: forall a. (a -> a -> a) -> QNamed a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> QNamed a -> a
foldl1 :: forall a. (a -> a -> a) -> QNamed a -> a
$ctoList :: forall a. QNamed a -> [a]
toList :: forall a. QNamed a -> [a]
$cnull :: forall a. QNamed a -> Bool
null :: forall a. QNamed a -> Bool
$clength :: forall a. QNamed a -> Int
length :: forall a. QNamed a -> Int
$celem :: forall a. Eq a => a -> QNamed a -> Bool
elem :: forall a. Eq a => a -> QNamed a -> Bool
$cmaximum :: forall a. Ord a => QNamed a -> a
maximum :: forall a. Ord a => QNamed a -> a
$cminimum :: forall a. Ord a => QNamed a -> a
minimum :: forall a. Ord a => QNamed a -> a
$csum :: forall a. Num a => QNamed a -> a
sum :: forall a. Num a => QNamed a -> a
$cproduct :: forall a. Num a => QNamed a -> a
product :: forall a. Num a => QNamed a -> a
Foldable, Functor QNamed
Foldable QNamed
(Functor QNamed, Foldable QNamed) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> QNamed a -> f (QNamed b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    QNamed (f a) -> f (QNamed a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> QNamed a -> m (QNamed b))
-> (forall (m :: * -> *) a.
    Monad m =>
    QNamed (m a) -> m (QNamed a))
-> Traversable QNamed
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => QNamed (m a) -> m (QNamed a)
forall (f :: * -> *) a.
Applicative f =>
QNamed (f a) -> f (QNamed a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QNamed a -> m (QNamed b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QNamed a -> f (QNamed b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QNamed a -> f (QNamed b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> QNamed a -> f (QNamed b)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
QNamed (f a) -> f (QNamed a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
QNamed (f a) -> f (QNamed a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QNamed a -> m (QNamed b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> QNamed a -> m (QNamed b)
$csequence :: forall (m :: * -> *) a. Monad m => QNamed (m a) -> m (QNamed a)
sequence :: forall (m :: * -> *) a. Monad m => QNamed (m a) -> m (QNamed a)
Traversable)

-- | A module name is just a qualified name.
--
-- The 'SetRange' instance for module names sets all individual ranges
-- to the given one.
newtype ModuleName = MName { ModuleName -> [Name]
mnameToList :: [Name] }
  deriving (ModuleName -> ModuleName -> Bool
(ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool) -> Eq ModuleName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModuleName -> ModuleName -> Bool
== :: ModuleName -> ModuleName -> Bool
$c/= :: ModuleName -> ModuleName -> Bool
/= :: ModuleName -> ModuleName -> Bool
Eq, Eq ModuleName
Eq ModuleName =>
(ModuleName -> ModuleName -> Ordering)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> Bool)
-> (ModuleName -> ModuleName -> ModuleName)
-> (ModuleName -> ModuleName -> ModuleName)
-> Ord ModuleName
ModuleName -> ModuleName -> Bool
ModuleName -> ModuleName -> Ordering
ModuleName -> ModuleName -> ModuleName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ModuleName -> ModuleName -> Ordering
compare :: ModuleName -> ModuleName -> Ordering
$c< :: ModuleName -> ModuleName -> Bool
< :: ModuleName -> ModuleName -> Bool
$c<= :: ModuleName -> ModuleName -> Bool
<= :: ModuleName -> ModuleName -> Bool
$c> :: ModuleName -> ModuleName -> Bool
> :: ModuleName -> ModuleName -> Bool
$c>= :: ModuleName -> ModuleName -> Bool
>= :: ModuleName -> ModuleName -> Bool
$cmax :: ModuleName -> ModuleName -> ModuleName
max :: ModuleName -> ModuleName -> ModuleName
$cmin :: ModuleName -> ModuleName -> ModuleName
min :: ModuleName -> ModuleName -> ModuleName
Ord, ModuleName -> ()
(ModuleName -> ()) -> NFData ModuleName
forall a. (a -> ()) -> NFData a
$crnf :: ModuleName -> ()
rnf :: ModuleName -> ()
NFData, ModuleName
ModuleName -> Bool
ModuleName -> (ModuleName -> Bool) -> Null ModuleName
forall a. a -> (a -> Bool) -> Null a
$cempty :: ModuleName
empty :: ModuleName
$cnull :: ModuleName -> Bool
null :: ModuleName -> Bool
Null, Eq ModuleName
Eq ModuleName =>
(Int -> ModuleName -> Int)
-> (ModuleName -> Int) -> Hashable ModuleName
Int -> ModuleName -> Int
ModuleName -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ModuleName -> Int
hashWithSalt :: Int -> ModuleName -> Int
$chash :: ModuleName -> Int
hash :: ModuleName -> Int
Hashable)

-- | Ambiguous qualified names. Used for overloaded constructors.
--
-- A 'QName' in this collection might be equipped with lineage information
-- in form of an associated 'AbstractName' (which must contain the same 'QName').
--
-- Invariant: All the names in the map must have the same concrete,
-- unqualified name.  (This implies that they all have the same 'Range').
--
-- Don't use the constructor 'AmbQ' directly, use the smart constructors below!
newtype AmbiguousQName = AmbQ { AmbiguousQName -> Map1 NameId AmbQNameEntry
unAmbQ :: Map1 NameId AmbQNameEntry }
  deriving (AmbiguousQName -> AmbiguousQName -> Bool
(AmbiguousQName -> AmbiguousQName -> Bool)
-> (AmbiguousQName -> AmbiguousQName -> Bool) -> Eq AmbiguousQName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AmbiguousQName -> AmbiguousQName -> Bool
== :: AmbiguousQName -> AmbiguousQName -> Bool
$c/= :: AmbiguousQName -> AmbiguousQName -> Bool
/= :: AmbiguousQName -> AmbiguousQName -> Bool
Eq, Eq AmbiguousQName
Eq AmbiguousQName =>
(AmbiguousQName -> AmbiguousQName -> Ordering)
-> (AmbiguousQName -> AmbiguousQName -> Bool)
-> (AmbiguousQName -> AmbiguousQName -> Bool)
-> (AmbiguousQName -> AmbiguousQName -> Bool)
-> (AmbiguousQName -> AmbiguousQName -> Bool)
-> (AmbiguousQName -> AmbiguousQName -> AmbiguousQName)
-> (AmbiguousQName -> AmbiguousQName -> AmbiguousQName)
-> Ord AmbiguousQName
AmbiguousQName -> AmbiguousQName -> Bool
AmbiguousQName -> AmbiguousQName -> Ordering
AmbiguousQName -> AmbiguousQName -> AmbiguousQName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AmbiguousQName -> AmbiguousQName -> Ordering
compare :: AmbiguousQName -> AmbiguousQName -> Ordering
$c< :: AmbiguousQName -> AmbiguousQName -> Bool
< :: AmbiguousQName -> AmbiguousQName -> Bool
$c<= :: AmbiguousQName -> AmbiguousQName -> Bool
<= :: AmbiguousQName -> AmbiguousQName -> Bool
$c> :: AmbiguousQName -> AmbiguousQName -> Bool
> :: AmbiguousQName -> AmbiguousQName -> Bool
$c>= :: AmbiguousQName -> AmbiguousQName -> Bool
>= :: AmbiguousQName -> AmbiguousQName -> Bool
$cmax :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
max :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
$cmin :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
min :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
Ord, AmbiguousQName -> ()
(AmbiguousQName -> ()) -> NFData AmbiguousQName
forall a. (a -> ()) -> NFData a
$crnf :: AmbiguousQName -> ()
rnf :: AmbiguousQName -> ()
NFData, AmbiguousQName -> Int
AmbiguousQName -> Peano
(AmbiguousQName -> Int)
-> (AmbiguousQName -> Peano) -> Sized AmbiguousQName
forall a. (a -> Int) -> (a -> Peano) -> Sized a
$csize :: AmbiguousQName -> Int
size :: AmbiguousQName -> Int
$cnatSize :: AmbiguousQName -> Peano
natSize :: AmbiguousQName -> Peano
Sized)

-- | Alternative in 'AmbiguousQName'.
data AmbQNameEntry
  = AmbQName QName
      -- ^ 'QName' without lineage information.
  | AmbAbstractName AbstractName
      -- ^ 'QName' with lineage information, for error reporting.
  deriving (AmbQNameEntry -> AmbQNameEntry -> Bool
(AmbQNameEntry -> AmbQNameEntry -> Bool)
-> (AmbQNameEntry -> AmbQNameEntry -> Bool) -> Eq AmbQNameEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AmbQNameEntry -> AmbQNameEntry -> Bool
== :: AmbQNameEntry -> AmbQNameEntry -> Bool
$c/= :: AmbQNameEntry -> AmbQNameEntry -> Bool
/= :: AmbQNameEntry -> AmbQNameEntry -> Bool
Eq, Eq AmbQNameEntry
Eq AmbQNameEntry =>
(AmbQNameEntry -> AmbQNameEntry -> Ordering)
-> (AmbQNameEntry -> AmbQNameEntry -> Bool)
-> (AmbQNameEntry -> AmbQNameEntry -> Bool)
-> (AmbQNameEntry -> AmbQNameEntry -> Bool)
-> (AmbQNameEntry -> AmbQNameEntry -> Bool)
-> (AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry)
-> (AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry)
-> Ord AmbQNameEntry
AmbQNameEntry -> AmbQNameEntry -> Bool
AmbQNameEntry -> AmbQNameEntry -> Ordering
AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: AmbQNameEntry -> AmbQNameEntry -> Ordering
compare :: AmbQNameEntry -> AmbQNameEntry -> Ordering
$c< :: AmbQNameEntry -> AmbQNameEntry -> Bool
< :: AmbQNameEntry -> AmbQNameEntry -> Bool
$c<= :: AmbQNameEntry -> AmbQNameEntry -> Bool
<= :: AmbQNameEntry -> AmbQNameEntry -> Bool
$c> :: AmbQNameEntry -> AmbQNameEntry -> Bool
> :: AmbQNameEntry -> AmbQNameEntry -> Bool
$c>= :: AmbQNameEntry -> AmbQNameEntry -> Bool
>= :: AmbQNameEntry -> AmbQNameEntry -> Bool
$cmax :: AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
max :: AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
$cmin :: AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
min :: AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
Ord, Int -> AmbQNameEntry -> ShowS
[AmbQNameEntry] -> ShowS
AmbQNameEntry -> [Char]
(Int -> AmbQNameEntry -> ShowS)
-> (AmbQNameEntry -> [Char])
-> ([AmbQNameEntry] -> ShowS)
-> Show AmbQNameEntry
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AmbQNameEntry -> ShowS
showsPrec :: Int -> AmbQNameEntry -> ShowS
$cshow :: AmbQNameEntry -> [Char]
show :: AmbQNameEntry -> [Char]
$cshowList :: [AmbQNameEntry] -> ShowS
showList :: [AmbQNameEntry] -> ShowS
Show, (forall x. AmbQNameEntry -> Rep AmbQNameEntry x)
-> (forall x. Rep AmbQNameEntry x -> AmbQNameEntry)
-> Generic AmbQNameEntry
forall x. Rep AmbQNameEntry x -> AmbQNameEntry
forall x. AmbQNameEntry -> Rep AmbQNameEntry x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AmbQNameEntry -> Rep AmbQNameEntry x
from :: forall x. AmbQNameEntry -> Rep AmbQNameEntry x
$cto :: forall x. Rep AmbQNameEntry x -> AmbQNameEntry
to :: forall x. Rep AmbQNameEntry x -> AmbQNameEntry
Generic)

-- | A decoration of 'Agda.Syntax.Abstract.Name.QName'.
data AbstractName = AbsName
  { AbstractName -> QName
anameName    :: QName
    -- ^ The resolved qualified name.
  , AbstractName -> KindOfName
anameKind    :: KindOfName
    -- ^ The kind (definition, constructor, record field etc.).
  , AbstractName -> WhyInScope
anameLineage :: WhyInScope
    -- ^ Explanation where this name came from.
  , AbstractName -> NameMetadata
anameMetadata :: NameMetadata
    -- ^ Additional information needed during scope checking. Currently used
    --   for generalized data/record params.
  }
  deriving (Int -> AbstractName -> ShowS
[AbstractName] -> ShowS
AbstractName -> [Char]
(Int -> AbstractName -> ShowS)
-> (AbstractName -> [Char])
-> ([AbstractName] -> ShowS)
-> Show AbstractName
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AbstractName -> ShowS
showsPrec :: Int -> AbstractName -> ShowS
$cshow :: AbstractName -> [Char]
show :: AbstractName -> [Char]
$cshowList :: [AbstractName] -> ShowS
showList :: [AbstractName] -> ShowS
Show, (forall x. AbstractName -> Rep AbstractName x)
-> (forall x. Rep AbstractName x -> AbstractName)
-> Generic AbstractName
forall x. Rep AbstractName x -> AbstractName
forall x. AbstractName -> Rep AbstractName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AbstractName -> Rep AbstractName x
from :: forall x. AbstractName -> Rep AbstractName x
$cto :: forall x. Rep AbstractName x -> AbstractName
to :: forall x. Rep AbstractName x -> AbstractName
Generic)

-- | A decoration of abstract syntax module names.
data AbstractModule = AbsModule
  { AbstractModule -> ModuleName
amodName    :: ModuleName
    -- ^ The resolved module name.
  , AbstractModule -> WhyInScope
amodLineage :: WhyInScope
    -- ^ Explanation where this name came from.
  }
  deriving (Int -> AbstractModule -> ShowS
[AbstractModule] -> ShowS
AbstractModule -> [Char]
(Int -> AbstractModule -> ShowS)
-> (AbstractModule -> [Char])
-> ([AbstractModule] -> ShowS)
-> Show AbstractModule
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AbstractModule -> ShowS
showsPrec :: Int -> AbstractModule -> ShowS
$cshow :: AbstractModule -> [Char]
show :: AbstractModule -> [Char]
$cshowList :: [AbstractModule] -> ShowS
showList :: [AbstractModule] -> ShowS
Show, (forall x. AbstractModule -> Rep AbstractModule x)
-> (forall x. Rep AbstractModule x -> AbstractModule)
-> Generic AbstractModule
forall x. Rep AbstractModule x -> AbstractModule
forall x. AbstractModule -> Rep AbstractModule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AbstractModule -> Rep AbstractModule x
from :: forall x. AbstractModule -> Rep AbstractModule x
$cto :: forall x. Rep AbstractModule x -> AbstractModule
to :: forall x. Rep AbstractModule x -> AbstractModule
Generic)

-- | For the sake of parsing left-hand sides, we distinguish
--   constructor and record field names from defined names.

-- Note: order does matter in this enumeration, see 'isDefName'.
data KindOfName
  = ConName                  -- ^ Constructor name ('Inductive' or don't know).
  | CoConName                -- ^ Constructor name (definitely 'CoInductive').
  | FldName                  -- ^ Record field name.
  | PatternSynName           -- ^ Name of a pattern synonym.
  | GeneralizeName           -- ^ Name to be generalized
  | DisallowedGeneralizeName -- ^ Generalizable variable from a let open
  | MacroName                -- ^ Name of a macro
  | QuotableName             -- ^ A name that can only be quoted.
  -- Previous category @DefName@:
  -- (Refined in a flat manner as Enum and Bounded are not hereditary.)
  | DataName                 -- ^ Name of a @data@.
  | RecName                  -- ^ Name of a @record@.
  | FunName                  -- ^ Name of a defined function.
  | AxiomName                -- ^ Name of a @postulate@.
  | PrimName                 -- ^ Name of a @primitive@.
  | OtherDefName             -- ^ A @DefName@, but either other kind or don't know which kind.
  -- End @DefName@.  Keep these together in sequence, for sake of @isDefName@!
  deriving (KindOfName -> KindOfName -> Bool
(KindOfName -> KindOfName -> Bool)
-> (KindOfName -> KindOfName -> Bool) -> Eq KindOfName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KindOfName -> KindOfName -> Bool
== :: KindOfName -> KindOfName -> Bool
$c/= :: KindOfName -> KindOfName -> Bool
/= :: KindOfName -> KindOfName -> Bool
Eq, Eq KindOfName
Eq KindOfName =>
(KindOfName -> KindOfName -> Ordering)
-> (KindOfName -> KindOfName -> Bool)
-> (KindOfName -> KindOfName -> Bool)
-> (KindOfName -> KindOfName -> Bool)
-> (KindOfName -> KindOfName -> Bool)
-> (KindOfName -> KindOfName -> KindOfName)
-> (KindOfName -> KindOfName -> KindOfName)
-> Ord KindOfName
KindOfName -> KindOfName -> Bool
KindOfName -> KindOfName -> Ordering
KindOfName -> KindOfName -> KindOfName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KindOfName -> KindOfName -> Ordering
compare :: KindOfName -> KindOfName -> Ordering
$c< :: KindOfName -> KindOfName -> Bool
< :: KindOfName -> KindOfName -> Bool
$c<= :: KindOfName -> KindOfName -> Bool
<= :: KindOfName -> KindOfName -> Bool
$c> :: KindOfName -> KindOfName -> Bool
> :: KindOfName -> KindOfName -> Bool
$c>= :: KindOfName -> KindOfName -> Bool
>= :: KindOfName -> KindOfName -> Bool
$cmax :: KindOfName -> KindOfName -> KindOfName
max :: KindOfName -> KindOfName -> KindOfName
$cmin :: KindOfName -> KindOfName -> KindOfName
min :: KindOfName -> KindOfName -> KindOfName
Ord, Int -> KindOfName -> ShowS
[KindOfName] -> ShowS
KindOfName -> [Char]
(Int -> KindOfName -> ShowS)
-> (KindOfName -> [Char])
-> ([KindOfName] -> ShowS)
-> Show KindOfName
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KindOfName -> ShowS
showsPrec :: Int -> KindOfName -> ShowS
$cshow :: KindOfName -> [Char]
show :: KindOfName -> [Char]
$cshowList :: [KindOfName] -> ShowS
showList :: [KindOfName] -> ShowS
Show, Int -> KindOfName
KindOfName -> Int
KindOfName -> [KindOfName]
KindOfName -> KindOfName
KindOfName -> KindOfName -> [KindOfName]
KindOfName -> KindOfName -> KindOfName -> [KindOfName]
(KindOfName -> KindOfName)
-> (KindOfName -> KindOfName)
-> (Int -> KindOfName)
-> (KindOfName -> Int)
-> (KindOfName -> [KindOfName])
-> (KindOfName -> KindOfName -> [KindOfName])
-> (KindOfName -> KindOfName -> [KindOfName])
-> (KindOfName -> KindOfName -> KindOfName -> [KindOfName])
-> Enum KindOfName
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: KindOfName -> KindOfName
succ :: KindOfName -> KindOfName
$cpred :: KindOfName -> KindOfName
pred :: KindOfName -> KindOfName
$ctoEnum :: Int -> KindOfName
toEnum :: Int -> KindOfName
$cfromEnum :: KindOfName -> Int
fromEnum :: KindOfName -> Int
$cenumFrom :: KindOfName -> [KindOfName]
enumFrom :: KindOfName -> [KindOfName]
$cenumFromThen :: KindOfName -> KindOfName -> [KindOfName]
enumFromThen :: KindOfName -> KindOfName -> [KindOfName]
$cenumFromTo :: KindOfName -> KindOfName -> [KindOfName]
enumFromTo :: KindOfName -> KindOfName -> [KindOfName]
$cenumFromThenTo :: KindOfName -> KindOfName -> KindOfName -> [KindOfName]
enumFromThenTo :: KindOfName -> KindOfName -> KindOfName -> [KindOfName]
Enum, KindOfName
KindOfName -> KindOfName -> Bounded KindOfName
forall a. a -> a -> Bounded a
$cminBound :: KindOfName
minBound :: KindOfName
$cmaxBound :: KindOfName
maxBound :: KindOfName
Bounded, (forall x. KindOfName -> Rep KindOfName x)
-> (forall x. Rep KindOfName x -> KindOfName) -> Generic KindOfName
forall x. Rep KindOfName x -> KindOfName
forall x. KindOfName -> Rep KindOfName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KindOfName -> Rep KindOfName x
from :: forall x. KindOfName -> Rep KindOfName x
$cto :: forall x. Rep KindOfName x -> KindOfName
to :: forall x. Rep KindOfName x -> KindOfName
Generic)

-- | Where does a name come from?
--
--   This information is solely for reporting to the user,
--   see 'Agda.Interaction.InteractionTop.whyInScope'.
data WhyInScope
  = Defined
    -- ^ Defined in this module.
  | Opened C.QName WhyInScope
    -- ^ Imported from another module.
  | Applied C.QName WhyInScope
    -- ^ Imported by a module application.
  deriving (Int -> WhyInScope -> ShowS
[WhyInScope] -> ShowS
WhyInScope -> [Char]
(Int -> WhyInScope -> ShowS)
-> (WhyInScope -> [Char])
-> ([WhyInScope] -> ShowS)
-> Show WhyInScope
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WhyInScope -> ShowS
showsPrec :: Int -> WhyInScope -> ShowS
$cshow :: WhyInScope -> [Char]
show :: WhyInScope -> [Char]
$cshowList :: [WhyInScope] -> ShowS
showList :: [WhyInScope] -> ShowS
Show, (forall x. WhyInScope -> Rep WhyInScope x)
-> (forall x. Rep WhyInScope x -> WhyInScope) -> Generic WhyInScope
forall x. Rep WhyInScope x -> WhyInScope
forall x. WhyInScope -> Rep WhyInScope x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WhyInScope -> Rep WhyInScope x
from :: forall x. WhyInScope -> Rep WhyInScope x
$cto :: forall x. Rep WhyInScope x -> WhyInScope
to :: forall x. Rep WhyInScope x -> WhyInScope
Generic)

data NameMetadata = NameMetadata
  { NameMetadata -> Map QName Name
nameDataGeneralizedVars :: Map QName Name
  , NameMetadata -> IsInstance
nameDataIsInstance      :: IsInstance
  }
  deriving (Int -> NameMetadata -> ShowS
[NameMetadata] -> ShowS
NameMetadata -> [Char]
(Int -> NameMetadata -> ShowS)
-> (NameMetadata -> [Char])
-> ([NameMetadata] -> ShowS)
-> Show NameMetadata
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NameMetadata -> ShowS
showsPrec :: Int -> NameMetadata -> ShowS
$cshow :: NameMetadata -> [Char]
show :: NameMetadata -> [Char]
$cshowList :: [NameMetadata] -> ShowS
showList :: [NameMetadata] -> ShowS
Show, (forall x. NameMetadata -> Rep NameMetadata x)
-> (forall x. Rep NameMetadata x -> NameMetadata)
-> Generic NameMetadata
forall x. Rep NameMetadata x -> NameMetadata
forall x. NameMetadata -> Rep NameMetadata x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NameMetadata -> Rep NameMetadata x
from :: forall x. NameMetadata -> Rep NameMetadata x
$cto :: forall x. Rep NameMetadata x -> NameMetadata
to :: forall x. Rep NameMetadata x -> NameMetadata
Generic)

---------------------------------------------------------------------------
-- * Overloaded 'nameId'
---------------------------------------------------------------------------

class HasNameId a where
  nameId :: a -> NameId

instance HasNameId Name where
  nameId :: Name -> NameId
nameId = Name -> NameId
_nameId

instance HasNameId QName where
  nameId :: QName -> NameId
nameId = Name -> NameId
forall a. HasNameId a => a -> NameId
nameId (Name -> NameId) -> (QName -> Name) -> QName -> NameId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> Name
qnameName

instance HasNameId AbstractName where
  nameId :: AbstractName -> NameId
nameId = QName -> NameId
forall a. HasNameId a => a -> NameId
nameId (QName -> NameId)
-> (AbstractName -> QName) -> AbstractName -> NameId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> QName
anameName

---------------------------------------------------------------------------
-- * Overloaded 'nameBindingSite'
---------------------------------------------------------------------------

class HasNameBindingSite a where
  nameBindingSite :: a -> Range

instance HasNameBindingSite Name where
  nameBindingSite :: Name -> Range
nameBindingSite = Name -> Range
_nameBindingSite

instance HasNameBindingSite QName where
  nameBindingSite :: QName -> Range
nameBindingSite = Name -> Range
forall a. HasNameBindingSite a => a -> Range
nameBindingSite (Name -> Range) -> (QName -> Name) -> QName -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> Name
qnameName

instance HasNameBindingSite ModuleName where
  nameBindingSite :: ModuleName -> Range
nameBindingSite = QName -> Range
forall a. HasNameBindingSite a => a -> Range
nameBindingSite (QName -> Range) -> (ModuleName -> QName) -> ModuleName -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName -> QName
mnameToQName

instance HasNameBindingSite AbstractName where
  nameBindingSite :: AbstractName -> Range
nameBindingSite = QName -> Range
forall a. HasNameBindingSite a => a -> Range
nameBindingSite (QName -> Range)
-> (AbstractName -> QName) -> AbstractName -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> QName
anameName

instance HasNameBindingSite AbstractModule where
  nameBindingSite :: AbstractModule -> Range
nameBindingSite = ModuleName -> Range
forall a. HasNameBindingSite a => a -> Range
nameBindingSite (ModuleName -> Range)
-> (AbstractModule -> ModuleName) -> AbstractModule -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractModule -> ModuleName
amodName

---------------------------------------------------------------------------
-- * Class 'IsProjP'
---------------------------------------------------------------------------

-- | Check whether we are a projection pattern.
class IsProjP a where
  isProjP :: a -> Maybe (ProjOrigin, AmbiguousQName)

instance IsProjP a => IsProjP (Arg a) where
  isProjP :: Arg a -> Maybe (ProjOrigin, AmbiguousQName)
isProjP Arg a
p = case a -> Maybe (ProjOrigin, AmbiguousQName)
forall a. IsProjP a => a -> Maybe (ProjOrigin, AmbiguousQName)
isProjP (a -> Maybe (ProjOrigin, AmbiguousQName))
-> a -> Maybe (ProjOrigin, AmbiguousQName)
forall a b. (a -> b) -> a -> b
$ Arg a -> a
forall e. Arg e -> e
unArg Arg a
p of
    Just (ProjOrigin
ProjPostfix , AmbiguousQName
f)
     | Arg a -> Hiding
forall a. LensHiding a => a -> Hiding
getHiding Arg a
p Hiding -> Hiding -> Bool
forall a. Eq a => a -> a -> Bool
/= Hiding
NotHidden -> Maybe (ProjOrigin, AmbiguousQName)
forall a. Maybe a
Nothing
    Maybe (ProjOrigin, AmbiguousQName)
x -> Maybe (ProjOrigin, AmbiguousQName)
x

instance IsProjP a => IsProjP (Named n a) where
  isProjP :: Named n a -> Maybe (ProjOrigin, AmbiguousQName)
isProjP = a -> Maybe (ProjOrigin, AmbiguousQName)
forall a. IsProjP a => a -> Maybe (ProjOrigin, AmbiguousQName)
isProjP (a -> Maybe (ProjOrigin, AmbiguousQName))
-> (Named n a -> a)
-> Named n a
-> Maybe (ProjOrigin, AmbiguousQName)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Named n a -> a
forall name a. Named name a -> a
namedThing

instance IsProjP Void where
  isProjP :: Void -> Maybe (ProjOrigin, AmbiguousQName)
isProjP Void
_ = Maybe (ProjOrigin, AmbiguousQName)
forall a. HasCallStack => a
__IMPOSSIBLE__

---------------------------------------------------------------------------
-- * 'Name'
---------------------------------------------------------------------------

-- | Make a 'Name' from some kind of string.
class MkName a where
  -- | The 'Range' sets the /definition site/ of the name, not the use site.
  mkName :: Range -> NameId -> a -> Name

  mkName_ :: NameId -> a -> Name
  mkName_ = Range -> NameId -> a -> Name
forall a. MkName a => Range -> NameId -> a -> Name
mkName Range
forall a. Range' a
noRange

instance MkName String where
  mkName :: Range -> NameId -> [Char] -> Name
mkName Range
r NameId
i [Char]
s = NameId -> Name -> Range -> Fixity' -> Bool -> Name
makeName NameId
i (Range -> NameInScope -> NameParts -> Name
C.Name Range
forall a. Range' a
noRange NameInScope
InScope ([Char] -> NameParts
C.stringNameParts [Char]
s)) Range
r Fixity'
noFixity' Bool
False

makeName :: NameId -> C.Name -> Range -> Fixity' -> Bool -> Name
makeName :: NameId -> Name -> Range -> Fixity' -> Bool -> Name
makeName NameId
i Name
c Range
r Fixity'
f Bool
rec = NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
Name NameId
i Name
c Name
c Range
r Fixity'
f Bool
rec

nameToArgName :: Name -> ArgName
nameToArgName :: Name -> [Char]
nameToArgName = ShowS
stringToArgName ShowS -> (Name -> [Char]) -> Name -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> [Char]
forall a. Pretty a => a -> [Char]
prettyShow

namedArgName :: NamedArg Name -> ArgName
namedArgName :: NamedArg Name -> [Char]
namedArgName NamedArg Name
x = [Char] -> Maybe [Char] -> [Char]
forall a. a -> Maybe a -> a
fromMaybe (Name -> [Char]
nameToArgName (Name -> [Char]) -> Name -> [Char]
forall a b. (a -> b) -> a -> b
$ NamedArg Name -> Name
forall a. NamedArg a -> a
namedArg NamedArg Name
x) (Maybe [Char] -> [Char]) -> Maybe [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ NamedArg Name -> Maybe [Char]
forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe [Char]
bareNameOf NamedArg Name
x

-- | Ignoring the suffix.
sameRoot :: Name -> Name -> Bool
sameRoot :: Name -> Name -> Bool
sameRoot = Name -> Name -> Bool
C.sameRoot (Name -> Name -> Bool) -> (Name -> Name) -> Name -> Name -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Name -> Name
nameConcrete

---------------------------------------------------------------------------
-- * 'ModuleName'
---------------------------------------------------------------------------

-- | A module is anonymous if the qualification path ends in an underscore.
isAnonymousModuleName :: ModuleName -> Bool
isAnonymousModuleName :: ModuleName -> Bool
isAnonymousModuleName (MName [Name]
mms) = Bool -> (Name -> Bool) -> Maybe Name -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False Name -> Bool
forall a. IsNoName a => a -> Bool
isNoName (Maybe Name -> Bool) -> Maybe Name -> Bool
forall a b. (a -> b) -> a -> b
$ [Name] -> Maybe Name
forall a. [a] -> Maybe a
List.lastMaybe [Name]
mms

-- | Sets the ranges of the individual names in the module name to
-- match those of the corresponding concrete names. If the concrete
-- names are fewer than the number of module name name parts, then the
-- initial name parts get the range 'noRange'.
--
-- @C.D.E \`withRangesOf\` [A, B]@ returns @C.D.E@ but with ranges set
-- as follows:
--
-- * @C@: 'noRange'.
--
-- * @D@: the range of @A@.
--
-- * @E@: the range of @B@.
--
-- Precondition: The number of module name name parts has to be at
-- least as large as the length of the list.

withRangesOf :: ModuleName -> List1 C.Name -> ModuleName
MName [Name]
ms withRangesOf :: ModuleName -> List1 Name -> ModuleName
`withRangesOf` List1 Name
ns = if Int
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n then ModuleName
forall a. HasCallStack => a
__IMPOSSIBLE__ else [Name] -> ModuleName
MName ([Name] -> ModuleName) -> [Name] -> ModuleName
forall a b. (a -> b) -> a -> b
$
      (Range -> Name -> Name) -> [Range] -> [Name] -> [Name]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Range -> Name -> Name
forall a. SetRange a => Range -> a -> a
setRange (Int -> Range -> [Range]
forall a. Int -> a -> [a]
replicate (Int
m Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
n) Range
forall a. Range' a
noRange [Range] -> [Range] -> [Range]
forall a. [a] -> [a] -> [a]
++ (Name -> Range) -> [Name] -> [Range]
forall a b. (a -> b) -> [a] -> [b]
map Name -> Range
forall a. HasRange a => a -> Range
getRange (List1 Name -> [Item (List1 Name)]
forall l. IsList l => l -> [Item l]
List1.toList List1 Name
ns)) [Name]
ms
  where
    m :: Int
m = [Name] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Name]
ms
    n :: Int
n = List1 Name -> Int
forall a. NonEmpty a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length List1 Name
ns

-- | Like 'withRangesOf', but uses the name parts (qualifier + name)
-- of the qualified name as the list of concrete names.

withRangesOfQ :: ModuleName -> C.QName -> ModuleName
ModuleName
m withRangesOfQ :: ModuleName -> QName -> ModuleName
`withRangesOfQ` QName
q = ModuleName
m ModuleName -> List1 Name -> ModuleName
`withRangesOf` QName -> List1 Name
C.qnameParts QName
q

mnameFromList :: [Name] -> ModuleName
mnameFromList :: [Name] -> ModuleName
mnameFromList = [Name] -> ModuleName
MName

mnameFromList1 :: List1 Name -> ModuleName
mnameFromList1 :: List1 Name -> ModuleName
mnameFromList1 = [Name] -> ModuleName
MName ([Name] -> ModuleName)
-> (List1 Name -> [Name]) -> List1 Name -> ModuleName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. List1 Name -> [Item (List1 Name)]
List1 Name -> [Name]
forall l. IsList l => l -> [Item l]
List1.toList

mnameToList1 :: ModuleName -> List1 Name
mnameToList1 :: ModuleName -> List1 Name
mnameToList1 (MName [Name]
ns) = [Name] -> List1 Name -> (List1 Name -> List1 Name) -> List1 Name
forall a b. [a] -> b -> (List1 a -> b) -> b
List1.ifNull [Name]
ns List1 Name
forall a. HasCallStack => a
__IMPOSSIBLE__ List1 Name -> List1 Name
forall a. a -> a
id

noModuleName :: ModuleName
noModuleName :: ModuleName
noModuleName = [Name] -> ModuleName
mnameFromList []

commonParentModule :: ModuleName -> ModuleName -> ModuleName
commonParentModule :: ModuleName -> ModuleName -> ModuleName
commonParentModule ModuleName
m1 ModuleName
m2 =
  [Name] -> ModuleName
mnameFromList ([Name] -> ModuleName) -> [Name] -> ModuleName
forall a b. (a -> b) -> a -> b
$ [Name] -> [Name] -> [Name]
forall a. Eq a => [a] -> [a] -> [a]
List.commonPrefix (ModuleName -> [Name]
mnameToList ModuleName
m1) (ModuleName -> [Name]
mnameToList ModuleName
m2)

mnameToConcrete :: ModuleName -> C.QName
mnameToConcrete :: ModuleName -> QName
mnameToConcrete (MName []) = QName
forall a. HasCallStack => a
__IMPOSSIBLE__ -- C.QName C.noName_  -- should never happen?
mnameToConcrete (MName (Name
x:[Name]
xs)) = (Name -> QName -> QName) -> QName -> [Name] -> QName
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Name -> QName -> QName
C.Qual (Name -> QName
C.QName (Name -> QName) -> Name -> QName
forall a b. (a -> b) -> a -> b
$ List1 Name -> Name
forall a. NonEmpty a -> a
List1.last List1 Name
cs) ([Name] -> QName) -> [Name] -> QName
forall a b. (a -> b) -> a -> b
$ List1 Name -> [Name]
forall a. NonEmpty a -> [a]
List1.init List1 Name
cs
  where
    cs :: List1 Name
cs = (Name -> Name) -> List1 Name -> List1 Name
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Name -> Name
nameConcrete (Name
x Name -> [Name] -> List1 Name
forall a. a -> [a] -> NonEmpty a
:| [Name]
xs)

qualifyM :: ModuleName -> ModuleName -> ModuleName
qualifyM :: ModuleName -> ModuleName -> ModuleName
qualifyM ModuleName
m1 ModuleName
m2 = [Name] -> ModuleName
mnameFromList ([Name] -> ModuleName) -> [Name] -> ModuleName
forall a b. (a -> b) -> a -> b
$ ModuleName -> [Name]
mnameToList ModuleName
m1 [Name] -> [Name] -> [Name]
forall a. [a] -> [a] -> [a]
++ ModuleName -> [Name]
mnameToList ModuleName
m2

-- | Is the first module a weak parent of the second?
isLeParentModuleOf :: ModuleName -> ModuleName -> Bool
isLeParentModuleOf :: ModuleName -> ModuleName -> Bool
isLeParentModuleOf = [Name] -> [Name] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
List.isPrefixOf ([Name] -> [Name] -> Bool)
-> (ModuleName -> [Name]) -> ModuleName -> ModuleName -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` ModuleName -> [Name]
mnameToList

-- | Is the first module a proper parent of the second?
isLtParentModuleOf :: ModuleName -> ModuleName -> Bool
isLtParentModuleOf :: ModuleName -> ModuleName -> Bool
isLtParentModuleOf ModuleName
x ModuleName
y =
  Maybe [Name] -> Bool
forall a. Maybe a -> Bool
isJust (Maybe [Name] -> Bool) -> Maybe [Name] -> Bool
forall a b. (a -> b) -> a -> b
$ ((Name -> Name -> Bool) -> [Name] -> [Name] -> Maybe [Name]
forall a.
(a -> a -> Bool) -> Prefix a -> Prefix a -> Maybe (Prefix a)
List.stripPrefixBy Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
(==) ([Name] -> [Name] -> Maybe [Name])
-> (ModuleName -> [Name])
-> ModuleName
-> ModuleName
-> Maybe [Name]
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` ModuleName -> [Name]
mnameToList) ModuleName
x ModuleName
y

-- | Is the first module a weak child of the second?
isLeChildModuleOf :: ModuleName -> ModuleName -> Bool
isLeChildModuleOf :: ModuleName -> ModuleName -> Bool
isLeChildModuleOf = (ModuleName -> ModuleName -> Bool)
-> ModuleName -> ModuleName -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip ModuleName -> ModuleName -> Bool
isLeParentModuleOf

-- | Is the first module a proper child of the second?
isLtChildModuleOf :: ModuleName -> ModuleName -> Bool
isLtChildModuleOf :: ModuleName -> ModuleName -> Bool
isLtChildModuleOf = (ModuleName -> ModuleName -> Bool)
-> ModuleName -> ModuleName -> Bool
forall a b c. (a -> b -> c) -> b -> a -> c
flip ModuleName -> ModuleName -> Bool
isLtParentModuleOf

---------------------------------------------------------------------------
-- * 'QName'
---------------------------------------------------------------------------

qnameToList0 :: QName -> [Name]
qnameToList0 :: QName -> [Name]
qnameToList0 = List1 Name -> [Item (List1 Name)]
List1 Name -> [Name]
forall l. IsList l => l -> [Item l]
List1.toList (List1 Name -> [Name]) -> (QName -> List1 Name) -> QName -> [Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> List1 Name
qnameToList

qnameToList :: QName -> List1 Name
qnameToList :: QName -> List1 Name
qnameToList (QName ModuleName
m Name
x) = ModuleName -> [Name]
mnameToList ModuleName
m [Name] -> Name -> List1 Name
forall a. [a] -> a -> List1 a
`List1.snoc` Name
x

qnameFromList :: List1 Name -> QName
qnameFromList :: List1 Name -> QName
qnameFromList List1 Name
xs = ModuleName -> Name -> QName
QName ([Name] -> ModuleName
mnameFromList ([Name] -> ModuleName) -> [Name] -> ModuleName
forall a b. (a -> b) -> a -> b
$ List1 Name -> [Name]
forall a. NonEmpty a -> [a]
List1.init List1 Name
xs) (List1 Name -> Name
forall a. NonEmpty a -> a
List1.last List1 Name
xs)

qnameToMName :: QName -> ModuleName
qnameToMName :: QName -> ModuleName
qnameToMName = List1 Name -> ModuleName
mnameFromList1 (List1 Name -> ModuleName)
-> (QName -> List1 Name) -> QName -> ModuleName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> List1 Name
qnameToList

mnameToQName :: ModuleName -> QName
mnameToQName :: ModuleName -> QName
mnameToQName = List1 Name -> QName
qnameFromList (List1 Name -> QName)
-> (ModuleName -> List1 Name) -> ModuleName -> QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName -> List1 Name
mnameToList1

showQNameId :: QName -> String
showQNameId :: QName -> [Char]
showQNameId QName
q = [Word64] -> [Char]
forall a. Show a => a -> [Char]
show (NonEmpty Word64 -> [Item (NonEmpty Word64)]
forall l. IsList l => l -> [Item l]
List1.toList NonEmpty Word64
ns) [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"@" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ModuleNameHash -> [Char]
forall a. Show a => a -> [Char]
show (NonEmpty ModuleNameHash -> ModuleNameHash
forall a. NonEmpty a -> a
List1.head NonEmpty ModuleNameHash
ms)
  where
    (NonEmpty Word64
ns, NonEmpty ModuleNameHash
ms) = NonEmpty (Word64, ModuleNameHash)
-> (NonEmpty Word64, NonEmpty ModuleNameHash)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
List1.unzip (NonEmpty (Word64, ModuleNameHash)
 -> (NonEmpty Word64, NonEmpty ModuleNameHash))
-> NonEmpty (Word64, ModuleNameHash)
-> (NonEmpty Word64, NonEmpty ModuleNameHash)
forall a b. (a -> b) -> a -> b
$ (Name -> (Word64, ModuleNameHash))
-> List1 Name -> NonEmpty (Word64, ModuleNameHash)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NameId -> (Word64, ModuleNameHash)
unNameId (NameId -> (Word64, ModuleNameHash))
-> (Name -> NameId) -> Name -> (Word64, ModuleNameHash)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> NameId
forall a. HasNameId a => a -> NameId
nameId) (List1 Name -> NonEmpty (Word64, ModuleNameHash))
-> List1 Name -> NonEmpty (Word64, ModuleNameHash)
forall a b. (a -> b) -> a -> b
$ [Name] -> Name -> List1 Name
forall a. [a] -> a -> List1 a
List1.snoc (ModuleName -> [Name]
mnameToList (ModuleName -> [Name]) -> ModuleName -> [Name]
forall a b. (a -> b) -> a -> b
$ QName -> ModuleName
qnameModule QName
q) (QName -> Name
qnameName QName
q)
    unNameId :: NameId -> (Word64, ModuleNameHash)
unNameId (NameId Word64
n ModuleNameHash
m) = (Word64
n, ModuleNameHash
m)

-- | Turn a qualified name into a concrete name. This should only be used as a
--   fallback when looking up the right concrete name in the scope fails.
qnameToConcrete :: QName -> C.QName
qnameToConcrete :: QName -> QName
qnameToConcrete (QName ModuleName
m Name
x) =       -- Use the canonical name here (#5048)
   (Name -> QName -> QName) -> QName -> [Name] -> QName
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Name -> QName -> QName
C.Qual (Name -> QName -> QName)
-> (Name -> Name) -> Name -> QName -> QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name
nameConcrete) (Name -> QName
C.QName (Name -> QName) -> Name -> QName
forall a b. (a -> b) -> a -> b
$ Name -> Name
nameCanonical Name
x) (ModuleName -> [Name]
mnameToList ModuleName
m)

qualifyQ :: ModuleName -> QName -> QName
qualifyQ :: ModuleName -> QName -> QName
qualifyQ ModuleName
m QName
x = List1 Name -> QName
qnameFromList (List1 Name -> QName) -> List1 Name -> QName
forall a b. (a -> b) -> a -> b
$ ModuleName -> [Name]
mnameToList ModuleName
m [Name] -> List1 Name -> List1 Name
forall a. [a] -> NonEmpty a -> NonEmpty a
`List1.prependList` QName -> List1 Name
qnameToList QName
x

qualify :: ModuleName -> Name -> QName
qualify :: ModuleName -> Name -> QName
qualify = ModuleName -> Name -> QName
QName

-- | Convert a 'Name' to a 'QName' (add no module name).
qualify_ :: Name -> QName
qualify_ :: Name -> QName
qualify_ = ModuleName -> Name -> QName
qualify ModuleName
noModuleName

-- | Is the name an operator?

isOperator :: QName -> Bool
isOperator :: QName -> Bool
isOperator = Name -> Bool
C.isOperator (Name -> Bool) -> (QName -> Name) -> QName -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name
nameConcrete (Name -> Name) -> (QName -> Name) -> QName -> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> Name
qnameName

isInModule :: QName -> ModuleName -> Bool
isInModule :: QName -> ModuleName -> Bool
isInModule QName
q ModuleName
m = ModuleName -> [Name]
mnameToList ModuleName
m [Name] -> [Name] -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`List.isPrefixOf` QName -> [Name]
qnameToList0 QName
q

-- | Get the next version of the concrete name. For instance, @nextName "x" = "x₁"@.
--   The name must not be a 'NoName'.
nextName :: C.FreshNameMode -> Name -> Name
nextName :: FreshNameMode -> Name -> Name
nextName FreshNameMode
freshNameMode Name
x = Name
x { nameConcrete = C.nextName freshNameMode (nameConcrete x) }

---------------------------------------------------------------------------
-- * 'AmbiguousQName'
---------------------------------------------------------------------------

fromAmbQName :: AmbQNameEntry -> QName
fromAmbQName :: AmbQNameEntry -> QName
fromAmbQName = \case
  AmbQName QName
x -> QName
x
  AmbAbstractName AbstractName
x -> AbstractName -> QName
anameName AbstractName
x

-- | A singleton "ambiguous" name.
unambiguous :: QName -> AmbiguousQName
unambiguous :: QName -> AmbiguousQName
unambiguous = List1 QName -> AmbiguousQName
ambiguous (List1 QName -> AmbiguousQName)
-> (QName -> List1 QName) -> QName -> AmbiguousQName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> List1 QName
forall el coll. Singleton el coll => el -> coll
singleton

ambiguous :: List1 QName -> AmbiguousQName
ambiguous :: List1 QName -> AmbiguousQName
ambiguous = Map1 NameId AmbQNameEntry -> AmbiguousQName
AmbQ (Map1 NameId AmbQNameEntry -> AmbiguousQName)
-> (List1 QName -> Map1 NameId AmbQNameEntry)
-> List1 QName
-> AmbiguousQName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (NameId, AmbQNameEntry) -> Map1 NameId AmbQNameEntry
forall k a. Ord k => NonEmpty (k, a) -> NEMap k a
Map1.fromList (NonEmpty (NameId, AmbQNameEntry) -> Map1 NameId AmbQNameEntry)
-> (List1 QName -> NonEmpty (NameId, AmbQNameEntry))
-> List1 QName
-> Map1 NameId AmbQNameEntry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (QName -> (NameId, AmbQNameEntry))
-> List1 QName -> NonEmpty (NameId, AmbQNameEntry)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap \ QName
x -> (QName -> NameId
forall a. HasNameId a => a -> NameId
nameId QName
x, QName -> AmbQNameEntry
AmbQName QName
x)

-- | Get the first of the ambiguous names.
headAmbQ :: AmbiguousQName -> QName
headAmbQ :: AmbiguousQName -> QName
headAmbQ = List1 QName -> QName
forall a. NonEmpty a -> a
List1.head (List1 QName -> QName)
-> (AmbiguousQName -> List1 QName) -> AmbiguousQName -> QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AmbiguousQName -> List1 QName
getAmbiguous

-- | Is a name ambiguous.
isAmbiguous :: AmbiguousQName -> Bool
isAmbiguous :: AmbiguousQName -> Bool
isAmbiguous (AmbQ Map1 NameId AmbQNameEntry
m) = Map1 NameId AmbQNameEntry -> Int
forall a. Sized a => a -> Int
size Map1 NameId AmbQNameEntry
m Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1

-- | Get the name if unambiguous.
getUnambiguous :: AmbiguousQName -> Maybe QName
getUnambiguous :: AmbiguousQName -> Maybe QName
getUnambiguous AmbiguousQName
m
  | AmbiguousQName -> Int
forall a. Sized a => a -> Int
size AmbiguousQName
m Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 = QName -> Maybe QName
forall a. a -> Maybe a
Just (QName -> Maybe QName) -> QName -> Maybe QName
forall a b. (a -> b) -> a -> b
$ AmbiguousQName -> QName
headAmbQ AmbiguousQName
m
  | Bool
otherwise   = Maybe QName
forall a. Maybe a
Nothing

getAmbiguous :: AmbiguousQName -> List1 QName
getAmbiguous :: AmbiguousQName -> List1 QName
getAmbiguous = (AmbQNameEntry -> QName) -> NonEmpty AmbQNameEntry -> List1 QName
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap AmbQNameEntry -> QName
fromAmbQName (NonEmpty AmbQNameEntry -> List1 QName)
-> (AmbiguousQName -> NonEmpty AmbQNameEntry)
-> AmbiguousQName
-> List1 QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map1 NameId AmbQNameEntry -> NonEmpty AmbQNameEntry
forall k a. NEMap k a -> NonEmpty a
Map1.elems (Map1 NameId AmbQNameEntry -> NonEmpty AmbQNameEntry)
-> (AmbiguousQName -> Map1 NameId AmbQNameEntry)
-> AmbiguousQName
-> NonEmpty AmbQNameEntry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AmbiguousQName -> Map1 NameId AmbQNameEntry
unAmbQ

ambAbstractNames :: AmbiguousQName -> [AbstractName]
ambAbstractNames :: AmbiguousQName -> [AbstractName]
ambAbstractNames (AmbQ Map1 NameId AmbQNameEntry
xs) = ((AmbQNameEntry -> Maybe AbstractName)
-> NonEmpty AmbQNameEntry -> [AbstractName]
forall a b. (a -> Maybe b) -> List1 a -> [b]
`List1.mapMaybe` Map1 NameId AmbQNameEntry -> NonEmpty AmbQNameEntry
forall k a. NEMap k a -> NonEmpty a
Map1.elems Map1 NameId AmbQNameEntry
xs) \case
  AmbQName{} -> Maybe AbstractName
forall a. Maybe a
Nothing
  AmbAbstractName AbstractName
x -> AbstractName -> Maybe AbstractName
forall a. a -> Maybe a
Just AbstractName
x

unambigName :: AbstractName -> AmbiguousQName
unambigName :: AbstractName -> AmbiguousQName
unambigName = List1 AbstractName -> AmbiguousQName
ambigName (List1 AbstractName -> AmbiguousQName)
-> (AbstractName -> List1 AbstractName)
-> AbstractName
-> AmbiguousQName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> List1 AbstractName
forall el coll. Singleton el coll => el -> coll
singleton

ambigName :: List1 AbstractName -> AmbiguousQName
ambigName :: List1 AbstractName -> AmbiguousQName
ambigName = Map1 NameId AmbQNameEntry -> AmbiguousQName
AmbQ (Map1 NameId AmbQNameEntry -> AmbiguousQName)
-> (List1 AbstractName -> Map1 NameId AmbQNameEntry)
-> List1 AbstractName
-> AmbiguousQName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (NameId, AmbQNameEntry) -> Map1 NameId AmbQNameEntry
forall k a. Ord k => NonEmpty (k, a) -> NEMap k a
Map1.fromList (NonEmpty (NameId, AmbQNameEntry) -> Map1 NameId AmbQNameEntry)
-> (List1 AbstractName -> NonEmpty (NameId, AmbQNameEntry))
-> List1 AbstractName
-> Map1 NameId AmbQNameEntry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AbstractName -> (NameId, AmbQNameEntry))
-> List1 AbstractName -> NonEmpty (NameId, AmbQNameEntry)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap \ AbstractName
x -> (AbstractName -> NameId
forall a. HasNameId a => a -> NameId
nameId AbstractName
x, AbstractName -> AmbQNameEntry
AmbAbstractName AbstractName
x)

-- | Preserve lineage information from both maps, left-biased.
mergeAmbQ :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
mergeAmbQ :: AmbiguousQName -> AmbiguousQName -> AmbiguousQName
mergeAmbQ (AmbQ Map1 NameId AmbQNameEntry
xs) (AmbQ Map1 NameId AmbQNameEntry
ys) = Map1 NameId AmbQNameEntry -> AmbiguousQName
AmbQ ((AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry)
-> Map1 NameId AmbQNameEntry
-> Map1 NameId AmbQNameEntry
-> Map1 NameId AmbQNameEntry
forall k a.
Ord k =>
(a -> a -> a) -> NEMap k a -> NEMap k a -> NEMap k a
Map1.unionWith AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
forall a. Semigroup a => a -> a -> a
(<>) Map1 NameId AmbQNameEntry
xs Map1 NameId AmbQNameEntry
ys)

-- | Prefer 'AmbAbstractName' over 'AmbQName', left-biased.
instance Semigroup AmbQNameEntry where
  x :: AmbQNameEntry
x@AmbAbstractName{} <> :: AmbQNameEntry -> AmbQNameEntry -> AmbQNameEntry
<> AmbQNameEntry
_ = AmbQNameEntry
x
  AmbQNameEntry
_ <> y :: AmbQNameEntry
y@AmbAbstractName{} = AmbQNameEntry
y
  AmbQNameEntry
x <> AmbQNameEntry
_                   = AmbQNameEntry
x

---------------------------------------------------------------------------
-- * 'AbstractName'
---------------------------------------------------------------------------

---------------------------------------------------------------------------
-- * 'NameMetadata'
---------------------------------------------------------------------------

noMetadata :: NameMetadata
noMetadata :: NameMetadata
noMetadata = NameMetadata
forall a. Null a => a
empty

generalizedVarsMetadata :: Map QName Name -> NameMetadata
generalizedVarsMetadata :: Map QName Name -> NameMetadata
generalizedVarsMetadata Map QName Name
m = Map QName Name -> IsInstance -> NameMetadata
NameMetadata Map QName Name
m IsInstance
forall a. Null a => a
empty

instanceMetadata :: IsInstance -> NameMetadata
instanceMetadata :: IsInstance -> NameMetadata
instanceMetadata IsInstance
i = Map QName Name -> IsInstance -> NameMetadata
NameMetadata Map QName Name
forall a. Null a => a
empty IsInstance
i

instance IsInstanceDef NameMetadata where
  isInstanceDef :: NameMetadata -> Maybe KwRange
isInstanceDef = IsInstance -> Maybe KwRange
forall a. IsInstanceDef a => a -> Maybe KwRange
isInstanceDef (IsInstance -> Maybe KwRange)
-> (NameMetadata -> IsInstance) -> NameMetadata -> Maybe KwRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NameMetadata -> IsInstance
nameDataIsInstance

instance IsInstanceDef AbstractName where
  isInstanceDef :: AbstractName -> Maybe KwRange
isInstanceDef = NameMetadata -> Maybe KwRange
forall a. IsInstanceDef a => a -> Maybe KwRange
isInstanceDef (NameMetadata -> Maybe KwRange)
-> (AbstractName -> NameMetadata) -> AbstractName -> Maybe KwRange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> NameMetadata
anameMetadata

---------------------------------------------------------------------------
-- * Instances
---------------------------------------------------------------------------

-- | Important instances: 'Eq', 'Ord', 'Hashable'
--
--   For the identity and comparing of names, only the 'NameId' matters!

instance Eq Name where
  == :: Name -> Name -> Bool
(==) = NameId -> NameId -> Bool
forall a. Eq a => a -> a -> Bool
(==) (NameId -> NameId -> Bool)
-> (Name -> NameId) -> Name -> Name -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Name -> NameId
forall a. HasNameId a => a -> NameId
nameId

instance Ord Name where
  compare :: Name -> Name -> Ordering
compare = NameId -> NameId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (NameId -> NameId -> Ordering)
-> (Name -> NameId) -> Name -> Name -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Name -> NameId
forall a. HasNameId a => a -> NameId
nameId

instance Hashable Name where
  {-# INLINE hashWithSalt #-}
  hashWithSalt :: Int -> Name -> Int
hashWithSalt Int
salt = Int -> NameId -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt (NameId -> Int) -> (Name -> NameId) -> Name -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> NameId
forall a. HasNameId a => a -> NameId
nameId

-- QName

instance Eq QName where
  == :: QName -> QName -> Bool
(==) = Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
(==) (Name -> Name -> Bool) -> (QName -> Name) -> QName -> QName -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` QName -> Name
qnameName

instance Ord QName where
  compare :: QName -> QName -> Ordering
compare = Name -> Name -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (Name -> Name -> Ordering)
-> (QName -> Name) -> QName -> QName -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` QName -> Name
qnameName

instance Hashable QName where
  {-# INLINE hashWithSalt #-}
  hashWithSalt :: Int -> QName -> Int
hashWithSalt Int
salt = Int -> Name -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt (Name -> Int) -> (QName -> Name) -> QName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> Name
qnameName

-- AbstractName

instance Eq AbstractName where
  == :: AbstractName -> AbstractName -> Bool
(==) = QName -> QName -> Bool
forall a. Eq a => a -> a -> Bool
(==) (QName -> QName -> Bool)
-> (AbstractName -> QName) -> AbstractName -> AbstractName -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` AbstractName -> QName
anameName

instance Ord AbstractName where
  compare :: AbstractName -> AbstractName -> Ordering
compare = QName -> QName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (QName -> QName -> Ordering)
-> (AbstractName -> QName)
-> AbstractName
-> AbstractName
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` AbstractName -> QName
anameName

instance Hashable AbstractName where
  hashWithSalt :: Int -> AbstractName -> Int
hashWithSalt Int
salt = Int -> QName -> Int
forall a. Hashable a => Int -> a -> Int
hashWithSalt Int
salt (QName -> Int) -> (AbstractName -> QName) -> AbstractName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> QName
anameName

-- AbstractModule

instance Eq AbstractModule where
  == :: AbstractModule -> AbstractModule -> Bool
(==) = ModuleName -> ModuleName -> Bool
forall a. Eq a => a -> a -> Bool
(==) (ModuleName -> ModuleName -> Bool)
-> (AbstractModule -> ModuleName)
-> AbstractModule
-> AbstractModule
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` AbstractModule -> ModuleName
amodName

instance Ord AbstractModule where
  compare :: AbstractModule -> AbstractModule -> Ordering
compare = ModuleName -> ModuleName -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (ModuleName -> ModuleName -> Ordering)
-> (AbstractModule -> ModuleName)
-> AbstractModule
-> AbstractModule
-> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` AbstractModule -> ModuleName
amodName

------------------------------------------------------------------------
-- 'IsNoName' and 'Null' instances (checking for "_")
------------------------------------------------------------------------

-- | An abstract name is empty if its concrete name is empty.
instance IsNoName Name where
  isNoName :: Name -> Bool
isNoName = Name -> Bool
forall a. IsNoName a => a -> Bool
isNoName (Name -> Bool) -> (Name -> Name) -> Name -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name
nameConcrete

instance IsNoName ModuleName where
  isNoName :: ModuleName -> Bool
isNoName (MName [Name]
xs) = (Name -> Bool) -> [Name] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Name -> Bool
forall a. IsNoName a => a -> Bool
isNoName [Name]
xs

instance Null Name where
  empty :: Name
empty = NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
Name NameId
forall a. Null a => a
empty Name
forall a. Null a => a
empty Name
forall a. Null a => a
empty Range
forall a. Null a => a
empty Fixity'
forall a. Null a => a
empty Bool
forall a. Null a => a
empty
  null :: Name -> Bool
null = Name -> Bool
forall a. IsNoName a => a -> Bool
isNoName

instance Null QName where
  empty :: QName
empty = ModuleName -> Name -> QName
QName ModuleName
forall a. Null a => a
empty Name
forall a. Null a => a
empty
  null :: QName -> Bool
null (QName ModuleName
m Name
x) = ModuleName -> Bool
forall a. Null a => a -> Bool
null ModuleName
m Bool -> Bool -> Bool
&& Name -> Bool
forall a. Null a => a -> Bool
null Name
x

instance Null Suffix where
  empty :: Suffix
empty = Suffix
NoSuffix

instance Null NameMetadata where
  empty :: NameMetadata
empty = Map QName Name -> IsInstance -> NameMetadata
NameMetadata Map QName Name
forall a. Null a => a
empty IsInstance
forall a. Null a => a
empty
  null :: NameMetadata -> Bool
null (NameMetadata Map QName Name
m IsInstance
i) = Map QName Name -> Bool
forall a. Null a => a -> Bool
null Map QName Name
m Bool -> Bool -> Bool
&& IsInstance -> Bool
forall a. Null a => a -> Bool
null IsInstance
i

------------------------------------------------------------------------
-- 'NumHoles' instances
------------------------------------------------------------------------

instance NumHoles Name where
  numHoles :: Name -> Int
numHoles = Name -> Int
forall a. NumHoles a => a -> Int
numHoles (Name -> Int) -> (Name -> Name) -> Name -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name
nameConcrete

instance NumHoles QName where
  numHoles :: QName -> Int
numHoles = Name -> Int
forall a. NumHoles a => a -> Int
numHoles (Name -> Int) -> (QName -> Name) -> QName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> Name
qnameName

-- | We can have an instance for ambiguous names as all share a common concrete name.
instance NumHoles AmbiguousQName where
  numHoles :: AmbiguousQName -> Int
numHoles = QName -> Int
forall a. NumHoles a => a -> Int
numHoles (QName -> Int)
-> (AmbiguousQName -> QName) -> AmbiguousQName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AmbiguousQName -> QName
headAmbQ

------------------------------------------------------------------------
-- Name lenses
------------------------------------------------------------------------

lensQNameName :: Lens' QName Name
lensQNameName :: Lens' QName Name
lensQNameName Name -> f Name
f (QName ModuleName
m Name
n) = ModuleName -> Name -> QName
QName ModuleName
m (Name -> QName) -> f Name -> f QName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> f Name
f Name
n

-- | Van Laarhoven lens on 'anameName'.
lensAnameName :: Lens' AbstractName QName
lensAnameName :: Lens' AbstractName QName
lensAnameName QName -> f QName
f AbstractName
am = QName -> f QName
f (AbstractName -> QName
anameName AbstractName
am) f QName -> (QName -> AbstractName) -> f AbstractName
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ QName
m -> AbstractName
am { anameName = m }

-- | Van Laarhoven lens on 'amodName'.
lensAmodName :: Lens' AbstractModule ModuleName
lensAmodName :: Lens' AbstractModule ModuleName
lensAmodName ModuleName -> f ModuleName
f AbstractModule
am = ModuleName -> f ModuleName
f (AbstractModule -> ModuleName
amodName AbstractModule
am) f ModuleName -> (ModuleName -> AbstractModule) -> f AbstractModule
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ ModuleName
m -> AbstractModule
am { amodName = m }

------------------------------------------------------------------------
-- LensFixity' instances
------------------------------------------------------------------------

instance LensFixity' Name where
  lensFixity' :: Lens' Name Fixity'
lensFixity' Fixity' -> f Fixity'
f Name
n = Fixity' -> f Fixity'
f (Name -> Fixity'
nameFixity Name
n) f Fixity' -> (Fixity' -> Name) -> f Name
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \ Fixity'
fix' -> Name
n { nameFixity = fix' }

instance LensFixity' QName where
  lensFixity' :: Lens' QName Fixity'
lensFixity' = (Name -> f Name) -> QName -> f QName
Lens' QName Name
lensQNameName ((Name -> f Name) -> QName -> f QName)
-> ((Fixity' -> f Fixity') -> Name -> f Name)
-> (Fixity' -> f Fixity')
-> QName
-> f QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixity' -> f Fixity') -> Name -> f Name
forall a. LensFixity' a => Lens' a Fixity'
Lens' Name Fixity'
lensFixity'

------------------------------------------------------------------------
-- LensFixity instances
------------------------------------------------------------------------

instance LensFixity Name where
  lensFixity :: Lens' Name Fixity
lensFixity = (Fixity' -> f Fixity') -> Name -> f Name
forall a. LensFixity' a => Lens' a Fixity'
Lens' Name Fixity'
lensFixity' ((Fixity' -> f Fixity') -> Name -> f Name)
-> ((Fixity -> f Fixity) -> Fixity' -> f Fixity')
-> (Fixity -> f Fixity)
-> Name
-> f Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixity -> f Fixity) -> Fixity' -> f Fixity'
forall a. LensFixity a => Lens' a Fixity
Lens' Fixity' Fixity
lensFixity

instance LensFixity QName where
  lensFixity :: Lens' QName Fixity
lensFixity = (Fixity' -> f Fixity') -> QName -> f QName
forall a. LensFixity' a => Lens' a Fixity'
Lens' QName Fixity'
lensFixity' ((Fixity' -> f Fixity') -> QName -> f QName)
-> ((Fixity -> f Fixity) -> Fixity' -> f Fixity')
-> (Fixity -> f Fixity)
-> QName
-> f QName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixity -> f Fixity) -> Fixity' -> f Fixity'
forall a. LensFixity a => Lens' a Fixity
Lens' Fixity' Fixity
lensFixity

instance LensFixity AbstractName where
  lensFixity :: Lens' AbstractName Fixity
lensFixity = (QName -> f QName) -> AbstractName -> f AbstractName
Lens' AbstractName QName
lensAnameName ((QName -> f QName) -> AbstractName -> f AbstractName)
-> ((Fixity -> f Fixity) -> QName -> f QName)
-> (Fixity -> f Fixity)
-> AbstractName
-> f AbstractName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Fixity -> f Fixity) -> QName -> f QName
forall a. LensFixity a => Lens' a Fixity
Lens' QName Fixity
lensFixity

------------------------------------------------------------------------
-- LensInScope instances
------------------------------------------------------------------------

instance LensInScope Name where
  lensInScope :: Lens' Name NameInScope
lensInScope NameInScope -> f NameInScope
f n :: Name
n@Name{ nameConcrete :: Name -> Name
nameConcrete = Name
x } =
    (\Name
y -> Name
n { nameConcrete = y }) (Name -> Name) -> f Name -> f Name
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NameInScope -> f NameInScope) -> Name -> f Name
forall a. LensInScope a => Lens' a NameInScope
Lens' Name NameInScope
lensInScope NameInScope -> f NameInScope
f Name
x

instance LensInScope QName where
  lensInScope :: Lens' QName NameInScope
lensInScope NameInScope -> f NameInScope
f q :: QName
q@QName{ qnameName :: QName -> Name
qnameName = Name
n } =
    (\Name
n' -> QName
q { qnameName = n' }) (Name -> QName) -> f Name -> f QName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NameInScope -> f NameInScope) -> Name -> f Name
forall a. LensInScope a => Lens' a NameInScope
Lens' Name NameInScope
lensInScope NameInScope -> f NameInScope
f Name
n

------------------------------------------------------------------------
-- | Show instances (only for debug printing!)
--
-- Use 'prettyShow' to print names to the user.
------------------------------------------------------------------------

deriving instance Show Name
deriving instance Show ModuleName
deriving instance Show QName
deriving instance Show a => Show (QNamed a)
deriving instance Show AmbiguousQName

-- | Useful for debugging scoping problems
uglyShowName :: Name -> String
uglyShowName :: Name -> [Char]
uglyShowName Name
x = (NameId, Name) -> [Char]
forall a. Show a => a -> [Char]
show (Name -> NameId
forall a. HasNameId a => a -> NameId
nameId Name
x, Name -> Name
nameConcrete Name
x)

------------------------------------------------------------------------
-- Pretty instances
------------------------------------------------------------------------

instance Pretty Name where
  pretty :: Name -> Doc
pretty Name
n = Name -> Doc
forall a. Pretty a => a -> Doc
pretty (Name -> Name
nameConcrete Name
n) Doc -> Range -> Doc
forall a. HasRange a => Doc -> a -> Doc
`definedAt` (Name -> Range
forall a. HasNameBindingSite a => a -> Range
nameBindingSite Name
n)

instance Pretty ModuleName where
  pretty :: ModuleName -> Doc
pretty = [Doc] -> Doc
forall (t :: * -> *). Foldable t => t Doc -> Doc
hcat ([Doc] -> Doc) -> (ModuleName -> [Doc]) -> ModuleName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> [Doc] -> [Doc]
forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
punctuate Doc
"." ([Doc] -> [Doc]) -> (ModuleName -> [Doc]) -> ModuleName -> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name -> Doc) -> [Name] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map Name -> Doc
forall a. Pretty a => a -> Doc
pretty ([Name] -> [Doc]) -> (ModuleName -> [Name]) -> ModuleName -> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName -> [Name]
mnameToList

instance Pretty QName where
  pretty :: QName -> Doc
pretty = [Doc] -> Doc
forall (t :: * -> *). Foldable t => t Doc -> Doc
hcat ([Doc] -> Doc) -> (QName -> [Doc]) -> QName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> [Doc] -> [Doc]
forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
punctuate Doc
"." ([Doc] -> [Doc]) -> (QName -> [Doc]) -> QName -> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name -> Doc) -> [Name] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map Name -> Doc
forall a. Pretty a => a -> Doc
pretty ([Name] -> [Doc]) -> (QName -> [Name]) -> QName -> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> [Name]
qnameToList0 (QName -> [Name]) -> (QName -> QName) -> QName -> [Name]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> QName
useCanonical
    where
      -- #4735: When printing a fully qualified name (as done by primShowQName) we need to
      -- use the origincal concrete name, not the possibly renamed concrete name in 'nameConcrete'.
      useCanonical :: QName -> QName
useCanonical QName
q = QName
q { qnameName = (qnameName q) { nameConcrete = nameCanonical (qnameName q) } }

instance Pretty AmbiguousQName where
  pretty :: AmbiguousQName -> Doc
pretty AmbiguousQName
qs = [Doc] -> Doc
forall (t :: * -> *). Foldable t => t Doc -> Doc
hcat ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> NonEmpty Doc -> [Doc]
forall (t :: * -> *). Foldable t => Doc -> t Doc -> [Doc]
punctuate Doc
" | " (NonEmpty Doc -> [Doc]) -> NonEmpty Doc -> [Doc]
forall a b. (a -> b) -> a -> b
$ (QName -> Doc) -> List1 QName -> NonEmpty Doc
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap QName -> Doc
forall a. Pretty a => a -> Doc
pretty (List1 QName -> NonEmpty Doc) -> List1 QName -> NonEmpty Doc
forall a b. (a -> b) -> a -> b
$ AmbiguousQName -> List1 QName
getAmbiguous AmbiguousQName
qs

instance Pretty a => Pretty (QNamed a) where
  pretty :: QNamed a -> Doc
pretty (QNamed QName
a a
b) = QName -> Doc
forall a. Pretty a => a -> Doc
pretty QName
a Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Doc
"." Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> a -> Doc
forall a. Pretty a => a -> Doc
pretty a
b

instance Pretty Suffix where
  pretty :: Suffix -> Doc
pretty Suffix
NoSuffix   = Doc
forall a. Monoid a => a
mempty
  pretty (Suffix Integer
i) = [Char] -> Doc
forall a. [Char] -> Doc a
text (Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
i)

instance Pretty AbstractName where
  pretty :: AbstractName -> Doc
pretty = QName -> Doc
forall a. Pretty a => a -> Doc
pretty (QName -> Doc) -> (AbstractName -> QName) -> AbstractName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> QName
anameName

instance Pretty AbstractModule where
  pretty :: AbstractModule -> Doc
pretty = ModuleName -> Doc
forall a. Pretty a => a -> Doc
pretty (ModuleName -> Doc)
-> (AbstractModule -> ModuleName) -> AbstractModule -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractModule -> ModuleName
amodName

------------------------------------------------------------------------
-- Range instances
------------------------------------------------------------------------

-- HasRange

instance HasRange Name where
  getRange :: Name -> Range
getRange = Name -> Range
forall a. HasRange a => a -> Range
getRange (Name -> Range) -> (Name -> Name) -> Name -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Name
nameConcrete

instance HasRange ModuleName where
  getRange :: ModuleName -> Range
getRange (MName []) = Range
forall a. Range' a
noRange
  getRange (MName [Name]
xs) = [Name] -> Range
forall a. HasRange a => a -> Range
getRange [Name]
xs

instance HasRange QName where
  getRange :: QName -> Range
getRange QName
q = (ModuleName, Name) -> Range
forall a. HasRange a => a -> Range
getRange (QName -> ModuleName
qnameModule QName
q, QName -> Name
qnameName QName
q)

-- | The range of an @AmbiguousQName@ is the range of any of its
--   disambiguations (they are the same concrete name).
instance HasRange AmbiguousQName where
  getRange :: AmbiguousQName -> Range
getRange = QName -> Range
forall a. HasRange a => a -> Range
getRange (QName -> Range)
-> (AmbiguousQName -> QName) -> AmbiguousQName -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AmbiguousQName -> QName
headAmbQ

instance HasRange AmbQNameEntry where
  getRange :: AmbQNameEntry -> Range
getRange = \case
    AmbQName        QName
x -> QName -> Range
forall a. HasRange a => a -> Range
getRange QName
x
    AmbAbstractName AbstractName
x -> AbstractName -> Range
forall a. HasRange a => a -> Range
getRange AbstractName
x

-- SetRange

instance SetRange Name where
  setRange :: Range -> Name -> Name
setRange Range
r Name
x = Name
x { nameConcrete = setRange r $ nameConcrete x }

instance SetRange QName where
  setRange :: Range -> QName -> QName
setRange Range
r QName
q = QName
q { qnameModule = setRange r $ qnameModule q
                   , qnameName   = setRange r $ qnameName   q
                   }

instance SetRange ModuleName where
  setRange :: Range -> ModuleName -> ModuleName
setRange Range
r (MName [Name]
ns) = [Name] -> ModuleName
MName ((Range -> Name -> Name) -> [Range] -> [Name] -> [Name]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Range -> Name -> Name
forall a. SetRange a => Range -> a -> a
setRange [Range]
rs [Name]
ns)
    where
      -- Put the range only on the last name. Otherwise
      -- we get overlapping jump-to-definition links for all
      -- the parts (See #2666).
      rs :: [Range]
rs = Int -> Range -> [Range]
forall a. Int -> a -> [a]
replicate ([Name] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Name]
ns Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Range
forall a. Range' a
noRange [Range] -> [Range] -> [Range]
forall a. [a] -> [a] -> [a]
++ [Range
r]

-- KillRange

instance KillRange Name where
  killRange :: Name -> Name
killRange (Name NameId
a Name
b Name
c Range
d Fixity'
e Bool
f) =
    ((NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name)
-> NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
Name NameId
a Name
b Name
c Range
d Fixity'
e Bool
f) { _nameBindingSite = d }
    -- Andreas, 2017-07-25, issue #2649
    -- Preserve the nameBindingSite for error message.
    --
    -- Older remarks:
    --
    -- Andreas, 2014-03-30
    -- An experiment: what happens if we preserve
    -- the range of the binding site, but kill all
    -- other ranges before serialization?
    --
    -- Andreas, Makoto, 2014-10-18 AIM XX
    -- Kill all ranges in signature, including nameBindingSite.

instance KillRange ModuleName where
  killRange :: ModuleName -> ModuleName
killRange (MName [Name]
xs) = [Name] -> ModuleName
MName ([Name] -> ModuleName) -> [Name] -> ModuleName
forall a b. (a -> b) -> a -> b
$ [Name] -> [Name]
forall a. KillRange a => KillRangeT a
killRange [Name]
xs

instance KillRange QName where
  killRange :: QName -> QName
killRange (QName ModuleName
a Name
b) = (ModuleName -> Name -> QName) -> ModuleName -> Name -> QName
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN ModuleName -> Name -> QName
QName ModuleName
a Name
b
  -- killRange q = q { qnameModule = killRange $ qnameModule q
  --                 , qnameName   = killRange $ qnameName   q
  --                 }

instance KillRange AmbiguousQName where
  killRange :: AmbiguousQName -> AmbiguousQName
killRange (AmbQ Map1 NameId AmbQNameEntry
xs) = Map1 NameId AmbQNameEntry -> AmbiguousQName
AmbQ (Map1 NameId AmbQNameEntry -> AmbiguousQName)
-> Map1 NameId AmbQNameEntry -> AmbiguousQName
forall a b. (a -> b) -> a -> b
$ Map1 NameId AmbQNameEntry -> Map1 NameId AmbQNameEntry
forall a. KillRange a => KillRangeT a
killRange Map1 NameId AmbQNameEntry
xs

instance KillRange AmbQNameEntry where
  killRange :: AmbQNameEntry -> AmbQNameEntry
killRange = \case
    AmbQName QName
x -> (QName -> AmbQNameEntry) -> QName -> AmbQNameEntry
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN QName -> AmbQNameEntry
AmbQName QName
x
    AmbAbstractName AbstractName
x -> (AbstractName -> AmbQNameEntry) -> AbstractName -> AmbQNameEntry
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN AbstractName -> AmbQNameEntry
AmbAbstractName AbstractName
x

instance KillRange AbstractName where
  killRange :: AbstractName -> AbstractName
killRange (AbsName QName
a KindOfName
b WhyInScope
c NameMetadata
d) = (QName -> KindOfName -> WhyInScope -> NameMetadata -> AbstractName)
-> QName
-> KindOfName
-> WhyInScope
-> NameMetadata
-> AbstractName
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN QName -> KindOfName -> WhyInScope -> NameMetadata -> AbstractName
AbsName QName
a KindOfName
b WhyInScope
c NameMetadata
d

instance KillRange KindOfName where
  killRange :: KindOfName -> KindOfName
killRange = KindOfName -> KindOfName
forall a. a -> a
id

instance KillRange WhyInScope where
  killRange :: KillRangeT WhyInScope
killRange = \case
    WhyInScope
Defined -> WhyInScope
Defined
    Opened QName
a WhyInScope
b -> (QName -> KillRangeT WhyInScope) -> QName -> KillRangeT WhyInScope
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN QName -> KillRangeT WhyInScope
Opened QName
a WhyInScope
b
    Applied QName
a WhyInScope
b -> (QName -> KillRangeT WhyInScope) -> QName -> KillRangeT WhyInScope
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN QName -> KillRangeT WhyInScope
Applied QName
a WhyInScope
b

instance KillRange NameMetadata where
  killRange :: KillRangeT NameMetadata
killRange = \case
    NameMetadata Map QName Name
a IsInstance
b -> (Map QName Name -> IsInstance -> NameMetadata)
-> Map QName Name -> IsInstance -> NameMetadata
forall t (b :: Bool).
(KILLRANGE t b, IsBase t ~ b, All KillRange (Domains t)) =>
t -> t
killRangeN Map QName Name -> IsInstance -> NameMetadata
NameMetadata Map QName Name
a IsInstance
b


-- AbstractName

instance HasRange AbstractName where
  getRange :: AbstractName -> Range
getRange = QName -> Range
forall a. HasRange a => a -> Range
getRange (QName -> Range)
-> (AbstractName -> QName) -> AbstractName -> Range
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AbstractName -> QName
anameName

instance SetRange AbstractName where
  setRange :: Range -> AbstractName -> AbstractName
setRange Range
r AbstractName
x = AbstractName
x { anameName = setRange r $ anameName x }

------------------------------------------------------------------------
-- Sized instances
------------------------------------------------------------------------

instance Sized QName where
  size :: QName -> Int
size = List1 Name -> Int
forall a. Sized a => a -> Int
size (List1 Name -> Int) -> (QName -> List1 Name) -> QName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> List1 Name
qnameToList
  natSize :: QName -> Peano
natSize = List1 Name -> Peano
forall a. Sized a => a -> Peano
natSize (List1 Name -> Peano) -> (QName -> List1 Name) -> QName -> Peano
forall b c a. (b -> c) -> (a -> b) -> a -> c
. QName -> List1 Name
qnameToList

instance Sized ModuleName where
  size :: ModuleName -> Int
size = [Name] -> Int
forall a. Sized a => a -> Int
size ([Name] -> Int) -> (ModuleName -> [Name]) -> ModuleName -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName -> [Name]
mnameToList
  natSize :: ModuleName -> Peano
natSize = [Name] -> Peano
forall a. Sized a => a -> Peano
natSize ([Name] -> Peano) -> (ModuleName -> [Name]) -> ModuleName -> Peano
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModuleName -> [Name]
mnameToList

------------------------------------------------------------------------
-- NFData instances
------------------------------------------------------------------------

-- | The range is not forced.

instance NFData Name where
  rnf :: Name -> ()
rnf (Name NameId
_ Name
a Name
b Range
_ Fixity'
c Bool
d) = (Name, Name, Fixity', Bool) -> ()
forall a. NFData a => a -> ()
rnf (Name
a, Name
b, Fixity'
c, Bool
d)

instance NFData Suffix where
  rnf :: Suffix -> ()
rnf Suffix
NoSuffix   = ()
  rnf (Suffix Integer
_) = ()

instance NFData AbstractModule
instance NFData AbstractName
instance NFData AmbQNameEntry
instance NFData KindOfName
instance NFData NameMetadata
instance NFData QName
instance NFData WhyInScope