{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RecordWildCards   #-}
{-# LANGUAGE TypeFamilies      #-}

{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

\section[Name]{@Name@: to transmit name info from renamer to typechecker}
-}

-- |
-- #name_types#
-- GHC uses several kinds of name internally:
--
-- * 'GHC.Types.Name.Occurrence.OccName': see "GHC.Types.Name.Occurrence#name_types"
--
-- * 'GHC.Types.Name.Reader.RdrName': see "GHC.Types.Name.Reader#name_types"
--
-- * 'GHC.Types.Name.Name' is the type of names that have had their scoping and
--   binding resolved. They have an 'OccName' but also a 'GHC.Types.Unique.Unique'
--   that disambiguates Names that have the same 'OccName' and indeed is used for all
--   'Name' comparison. Names also contain information about where they originated
--   from, see "GHC.Types.Name#name_sorts"
--
-- * 'GHC.Types.Id.Id': see "GHC.Types.Id#name_types"
--
-- * 'GHC.Types.Var.Var': see "GHC.Types.Var#name_types"
--
-- #name_sorts#
-- Names are one of:
--
--  * External, if they name things declared in other modules. Some external
--    Names are wired in, i.e. they name primitives defined in the compiler itself
--
--  * Internal, if they name things in the module being compiled. Some internal
--    Names are system names, if they are names manufactured by the compiler

module GHC.Types.Name (
        -- * The main types
        Name,                                   -- Abstract
        BuiltInSyntax(..),

        -- ** Creating 'Name's
        mkSystemName, mkSystemNameAt,
        mkInternalName, mkClonedInternalName, mkDerivedInternalName,
        mkSystemVarName, mkSysTvName,
        mkFCallName,
        mkExternalName, mkWiredInName,

        -- ** Manipulating and deconstructing 'Name's
        nameUnique, setNameUnique,
        nameOccName, nameNameSpace, nameModule, nameModule_maybe,
        setNameLoc,
        tidyNameOcc,
        localiseName,

        nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,

        -- ** Predicates on 'Name's
        isSystemName, isInternalName, isExternalName,
        isTyVarName, isTyConName, isDataConName,
        isValName, isVarName, isDynLinkName,
        isWiredInName, isWiredIn, isBuiltInSyntax,
        isHoleName,
        wiredInNameTyThing_maybe,
        nameIsLocalOrFrom, nameIsHomePackage,
        nameIsHomePackageImport, nameIsFromExternalPackage,
        stableNameCmp,

        -- * Class 'NamedThing' and overloaded friends
        NamedThing(..),
        getSrcLoc, getSrcSpan, getOccString, getOccFS,

        pprInfixName, pprPrefixName, pprModulePrefix, pprNameUnqualified,
        nameStableString,

        -- Re-export the OccName stuff
        module GHC.Types.Name.Occurrence
    ) where

import GHC.Prelude

import {-# SOURCE #-} GHC.Types.TyThing ( TyThing )

import GHC.Platform
import GHC.Types.Name.Occurrence
import GHC.Unit.Module
import GHC.Unit.Home
import GHC.Types.SrcLoc
import GHC.Types.Unique
import GHC.Utils.Misc
import GHC.Data.Maybe
import GHC.Utils.Binary
import GHC.Data.FastString
import GHC.Utils.Outputable
import GHC.Utils.Panic

import Control.DeepSeq
import Data.Data

{-
************************************************************************
*                                                                      *
\subsection[Name-datatype]{The @Name@ datatype, and name construction}
*                                                                      *
************************************************************************
-}

-- | A unique, unambiguous name for something, containing information about where
-- that thing originated.
data Name = Name
  { Name -> NameSort
n_sort :: NameSort
    -- ^ What sort of name it is

  , Name -> OccName
n_occ  :: OccName
    -- ^ Its occurrence name.
    --
    -- NOTE: kept lazy to allow known names to be known constructor applications
    -- and to inline better. See Note [Fast comparison for built-in Names]

  , Name -> Unique
n_uniq :: {-# UNPACK #-} !Unique
    -- ^ Its unique.

  , Name -> SrcSpan
n_loc  :: !SrcSpan
    -- ^ Definition site
    --
    -- NOTE: we make the n_loc field strict to eliminate some potential
    -- (and real!) space leaks, due to the fact that we don't look at
    -- the SrcLoc in a Name all that often.
  }

-- See Note [About the NameSorts]
data NameSort
  = External Module

  | WiredIn Module TyThing BuiltInSyntax
        -- A variant of External, for wired-in things

  | Internal            -- A user-defined Id or TyVar
                        -- defined in the module being compiled

  | System              -- A system-defined Id or TyVar.  Typically the
                        -- OccName is very uninformative (like 's')

instance Outputable NameSort where
  ppr :: NameSort -> SDoc
ppr (External Module
_)    = String -> SDoc
text String
"external"
  ppr (WiredIn Module
_ TyThing
_ BuiltInSyntax
_) = String -> SDoc
text String
"wired-in"
  ppr  NameSort
Internal       = String -> SDoc
text String
"internal"
  ppr  NameSort
System         = String -> SDoc
text String
"system"

instance NFData Name where
  rnf :: Name -> ()
rnf Name{OccName
Unique
SrcSpan
NameSort
n_loc :: SrcSpan
n_uniq :: Unique
n_occ :: OccName
n_sort :: NameSort
n_loc :: Name -> SrcSpan
n_uniq :: Name -> Unique
n_occ :: Name -> OccName
n_sort :: Name -> NameSort
..} = forall a. NFData a => a -> ()
rnf NameSort
n_sort

instance NFData NameSort where
  rnf :: NameSort -> ()
rnf (External Module
m) = forall a. NFData a => a -> ()
rnf Module
m
  rnf (WiredIn Module
m TyThing
t BuiltInSyntax
b) = forall a. NFData a => a -> ()
rnf Module
m seq :: forall a b. a -> b -> b
`seq` TyThing
t seq :: forall a b. a -> b -> b
`seq` BuiltInSyntax
b seq :: forall a b. a -> b -> b
`seq` ()
    -- XXX this is a *lie*, we're not going to rnf the TyThing, but
    -- since the TyThings for WiredIn Names are all static they can't
    -- be hiding space leaks or errors.
  rnf NameSort
Internal = ()
  rnf NameSort
System = ()

-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples,
-- which have special syntactic forms.  They aren't in scope
-- as such.
data BuiltInSyntax = BuiltInSyntax | UserSyntax

{-
Note [Fast comparison for built-in Names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this wired-in Name in GHC.Builtin.Names:

   int8TyConName = tcQual gHC_INT  (fsLit "Int8")  int8TyConKey

Ultimately this turns into something like:

   int8TyConName = Name gHC_INT (mkOccName ..."Int8") int8TyConKey

So a comparison like `x == int8TyConName` will turn into `getUnique x ==
int8TyConKey`, nice and efficient.  But if the `n_occ` field is strict, that
definition will look like:

   int8TyCOnName = case (mkOccName..."Int8") of occ ->
                   Name gHC_INT occ int8TyConKey

and now the comparison will not optimise.  This matters even more when there are
numerous comparisons (see #19386):

if | tc == int8TyCon  -> ...
   | tc == int16TyCon -> ...
   ...etc...

when we would like to get a single multi-branched case.

TL;DR: we make the `n_occ` field lazy.
-}

{-
Note [About the NameSorts]

1.  Initially, top-level Ids (including locally-defined ones) get External names,
    and all other local Ids get Internal names

2.  In any invocation of GHC, an External Name for "M.x" has one and only one
    unique.  This unique association is ensured via the Name Cache;
    see Note [The Name Cache] in GHC.Iface.Env.

3.  Things with a External name are given C static labels, so they finally
    appear in the .o file's symbol table.  They appear in the symbol table
    in the form M.n.  If originally-local things have this property they
    must be made @External@ first.

4.  In the tidy-core phase, a External that is not visible to an importer
    is changed to Internal, and a Internal that is visible is changed to External

5.  A System Name differs in the following ways:
        a) has unique attached when printing dumps
        b) unifier eliminates sys tyvars in favour of user provs where possible

    Before anything gets printed in interface files or output code, it's
    fed through a 'tidy' processor, which zaps the OccNames to have
    unique names; and converts all sys-locals to user locals
    If any desugarer sys-locals have survived that far, they get changed to
    "ds1", "ds2", etc.

Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])

Wired-in thing  => The thing (Id, TyCon) is fully known to the compiler,
                   not read from an interface file.
                   E.g. Bool, True, Int, Float, and many others

All built-in syntax is for wired-in things.
-}

instance HasOccName Name where
  occName :: Name -> OccName
occName = Name -> OccName
nameOccName

nameUnique              :: Name -> Unique
nameOccName             :: Name -> OccName
nameNameSpace           :: Name -> NameSpace
nameModule              :: HasDebugCallStack => Name -> Module
nameSrcLoc              :: Name -> SrcLoc
nameSrcSpan             :: Name -> SrcSpan

nameUnique :: Name -> Unique
nameUnique    Name
name = Name -> Unique
n_uniq Name
name
nameOccName :: Name -> OccName
nameOccName   Name
name = Name -> OccName
n_occ  Name
name
nameNameSpace :: Name -> NameSpace
nameNameSpace Name
name = OccName -> NameSpace
occNameSpace (Name -> OccName
n_occ Name
name)
nameSrcLoc :: Name -> SrcLoc
nameSrcLoc    Name
name = SrcSpan -> SrcLoc
srcSpanStart (Name -> SrcSpan
n_loc Name
name)
nameSrcSpan :: Name -> SrcSpan
nameSrcSpan   Name
name = Name -> SrcSpan
n_loc  Name
name

{-
************************************************************************
*                                                                      *
\subsection{Predicates on names}
*                                                                      *
************************************************************************
-}

isInternalName    :: Name -> Bool
isExternalName    :: Name -> Bool
isSystemName      :: Name -> Bool
isWiredInName     :: Name -> Bool

isWiredInName :: Name -> Bool
isWiredInName (Name {n_sort :: Name -> NameSort
n_sort = WiredIn Module
_ TyThing
_ BuiltInSyntax
_}) = Bool
True
isWiredInName Name
_                               = Bool
False

isWiredIn :: NamedThing thing => thing -> Bool
isWiredIn :: forall thing. NamedThing thing => thing -> Bool
isWiredIn = Name -> Bool
isWiredInName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NamedThing a => a -> Name
getName

wiredInNameTyThing_maybe :: Name -> Maybe TyThing
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
wiredInNameTyThing_maybe (Name {n_sort :: Name -> NameSort
n_sort = WiredIn Module
_ TyThing
thing BuiltInSyntax
_}) = forall a. a -> Maybe a
Just TyThing
thing
wiredInNameTyThing_maybe Name
_                                   = forall a. Maybe a
Nothing

isBuiltInSyntax :: Name -> Bool
isBuiltInSyntax :: Name -> Bool
isBuiltInSyntax (Name {n_sort :: Name -> NameSort
n_sort = WiredIn Module
_ TyThing
_ BuiltInSyntax
BuiltInSyntax}) = Bool
True
isBuiltInSyntax Name
_                                           = Bool
False

isExternalName :: Name -> Bool
isExternalName (Name {n_sort :: Name -> NameSort
n_sort = External Module
_})    = Bool
True
isExternalName (Name {n_sort :: Name -> NameSort
n_sort = WiredIn Module
_ TyThing
_ BuiltInSyntax
_}) = Bool
True
isExternalName Name
_                               = Bool
False

isInternalName :: Name -> Bool
isInternalName Name
name = Bool -> Bool
not (Name -> Bool
isExternalName Name
name)

isHoleName :: Name -> Bool
isHoleName :: Name -> Bool
isHoleName = forall u. GenModule (GenUnit u) -> Bool
isHoleModule forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasDebugCallStack => Name -> Module
nameModule

-- | Will the 'Name' come from a dynamically linked package?
isDynLinkName :: Platform -> Module -> Name -> Bool
isDynLinkName :: Platform -> Module -> Name -> Bool
isDynLinkName Platform
platform Module
this_mod Name
name
  | Just Module
mod <- Name -> Maybe Module
nameModule_maybe Name
name
    -- Issue #8696 - when GHC is dynamically linked, it will attempt
    -- to load the dynamic dependencies of object files at compile
    -- time for things like QuasiQuotes or
    -- TemplateHaskell. Unfortunately, this interacts badly with
    -- intra-package linking, because we don't generate indirect
    -- (dynamic) symbols for intra-package calls. This means that if a
    -- module with an intra-package call is loaded without its
    -- dependencies, then GHC fails to link.
    --
    -- In the mean time, always force dynamic indirections to be
    -- generated: when the module name isn't the module being
    -- compiled, references are dynamic.
    = case Platform -> OS
platformOS Platform
platform of
        -- On Windows the hack for #8696 makes it unlinkable.
        -- As the entire setup of the code from Cmm down to the RTS expects
        -- the use of trampolines for the imported functions only when
        -- doing intra-package linking, e.g. referring to a symbol defined in the same
        -- package should not use a trampoline.
        -- I much rather have dynamic TH not supported than the entire Dynamic linking
        -- not due to a hack.
        -- Also not sure this would break on Windows anyway.
        OS
OSMinGW32 -> forall unit. GenModule unit -> unit
moduleUnit Module
mod forall a. Eq a => a -> a -> Bool
/= forall unit. GenModule unit -> unit
moduleUnit Module
this_mod

        -- For the other platforms, still perform the hack
        OS
_         -> Module
mod forall a. Eq a => a -> a -> Bool
/= Module
this_mod

  | Bool
otherwise = Bool
False  -- no, it is not even an external name


nameModule :: HasDebugCallStack => Name -> Module
nameModule Name
name =
  Name -> Maybe Module
nameModule_maybe Name
name forall a. Maybe a -> a -> a
`orElse`
  forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"nameModule" (forall a. Outputable a => a -> SDoc
ppr (Name -> NameSort
n_sort Name
name) SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Name
name)

nameModule_maybe :: Name -> Maybe Module
nameModule_maybe :: Name -> Maybe Module
nameModule_maybe (Name { n_sort :: Name -> NameSort
n_sort = External Module
mod})    = forall a. a -> Maybe a
Just Module
mod
nameModule_maybe (Name { n_sort :: Name -> NameSort
n_sort = WiredIn Module
mod TyThing
_ BuiltInSyntax
_}) = forall a. a -> Maybe a
Just Module
mod
nameModule_maybe Name
_                                  = forall a. Maybe a
Nothing

nameIsLocalOrFrom :: Module -> Name -> Bool
-- ^ Returns True if the name is
--   (a) Internal
--   (b) External but from the specified module
--   (c) External but from the 'interactive' package
--
-- The key idea is that
--    False means: the entity is defined in some other module
--                 you can find the details (type, fixity, instances)
--                     in some interface file
--                 those details will be stored in the EPT or HPT
--
--    True means:  the entity is defined in this module or earlier in
--                     the GHCi session
--                 you can find details (type, fixity, instances) in the
--                     TcGblEnv or TcLclEnv
--
-- The isInteractiveModule part is because successive interactions of a GHCi session
-- each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come
-- from the magic 'interactive' package; and all the details are kept in the
-- TcLclEnv, TcGblEnv, NOT in the HPT or EPT.
-- See Note [The interactive package] in "GHC.Runtime.Context"

nameIsLocalOrFrom :: Module -> Name -> Bool
nameIsLocalOrFrom Module
from Name
name
  | Just Module
mod <- Name -> Maybe Module
nameModule_maybe Name
name = Module
from forall a. Eq a => a -> a -> Bool
== Module
mod Bool -> Bool -> Bool
|| Module -> Bool
isInteractiveModule Module
mod
  | Bool
otherwise                         = Bool
True

nameIsHomePackage :: Module -> Name -> Bool
-- True if the Name is defined in module of this package
nameIsHomePackage :: Module -> Name -> Bool
nameIsHomePackage Module
this_mod
  = \Name
nm -> case Name -> NameSort
n_sort Name
nm of
              External Module
nm_mod    -> forall unit. GenModule unit -> unit
moduleUnit Module
nm_mod forall a. Eq a => a -> a -> Bool
== Unit
this_pkg
              WiredIn Module
nm_mod TyThing
_ BuiltInSyntax
_ -> forall unit. GenModule unit -> unit
moduleUnit Module
nm_mod forall a. Eq a => a -> a -> Bool
== Unit
this_pkg
              NameSort
Internal -> Bool
True
              NameSort
System   -> Bool
False
  where
    this_pkg :: Unit
this_pkg = forall unit. GenModule unit -> unit
moduleUnit Module
this_mod

nameIsHomePackageImport :: Module -> Name -> Bool
-- True if the Name is defined in module of this package
-- /other than/ the this_mod
nameIsHomePackageImport :: Module -> Name -> Bool
nameIsHomePackageImport Module
this_mod
  = \Name
nm -> case Name -> Maybe Module
nameModule_maybe Name
nm of
              Maybe Module
Nothing -> Bool
False
              Just Module
nm_mod -> Module
nm_mod forall a. Eq a => a -> a -> Bool
/= Module
this_mod
                          Bool -> Bool -> Bool
&& forall unit. GenModule unit -> unit
moduleUnit Module
nm_mod forall a. Eq a => a -> a -> Bool
== Unit
this_pkg
  where
    this_pkg :: Unit
this_pkg = forall unit. GenModule unit -> unit
moduleUnit Module
this_mod

-- | Returns True if the Name comes from some other package: neither this
-- package nor the interactive package.
nameIsFromExternalPackage :: HomeUnit -> Name -> Bool
nameIsFromExternalPackage :: HomeUnit -> Name -> Bool
nameIsFromExternalPackage HomeUnit
home_unit Name
name
  | Just Module
mod <- Name -> Maybe Module
nameModule_maybe Name
name
  , HomeUnit -> Module -> Bool
notHomeModule HomeUnit
home_unit Module
mod   -- Not the current unit
  , Bool -> Bool
not (Module -> Bool
isInteractiveModule Module
mod) -- Not the 'interactive' package
  = Bool
True
  | Bool
otherwise
  = Bool
False

isTyVarName :: Name -> Bool
isTyVarName :: Name -> Bool
isTyVarName Name
name = OccName -> Bool
isTvOcc (Name -> OccName
nameOccName Name
name)

isTyConName :: Name -> Bool
isTyConName :: Name -> Bool
isTyConName Name
name = OccName -> Bool
isTcOcc (Name -> OccName
nameOccName Name
name)

isDataConName :: Name -> Bool
isDataConName :: Name -> Bool
isDataConName Name
name = OccName -> Bool
isDataOcc (Name -> OccName
nameOccName Name
name)

isValName :: Name -> Bool
isValName :: Name -> Bool
isValName Name
name = OccName -> Bool
isValOcc (Name -> OccName
nameOccName Name
name)

isVarName :: Name -> Bool
isVarName :: Name -> Bool
isVarName = OccName -> Bool
isVarOcc forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> OccName
nameOccName

isSystemName :: Name -> Bool
isSystemName (Name {n_sort :: Name -> NameSort
n_sort = NameSort
System}) = Bool
True
isSystemName Name
_                        = Bool
False

{-
************************************************************************
*                                                                      *
\subsection{Making names}
*                                                                      *
************************************************************************
-}

-- | Create a name which is (for now at least) local to the current module and hence
-- does not need a 'Module' to disambiguate it from other 'Name's
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq OccName
occ SrcSpan
loc = Name { n_uniq :: Unique
n_uniq = Unique
uniq
                                   , n_sort :: NameSort
n_sort = NameSort
Internal
                                   , n_occ :: OccName
n_occ = OccName
occ
                                   , n_loc :: SrcSpan
n_loc = SrcSpan
loc }
        -- NB: You might worry that after lots of huffing and
        -- puffing we might end up with two local names with distinct
        -- uniques, but the same OccName.  Indeed we can, but that's ok
        --      * the insides of the compiler don't care: they use the Unique
        --      * when printing for -ddump-xxx you can switch on -dppr-debug to get the
        --        uniques if you get confused
        --      * for interface files we tidyCore first, which makes
        --        the OccNames distinct when they need to be

mkClonedInternalName :: Unique -> Name -> Name
mkClonedInternalName :: Unique -> Name -> Name
mkClonedInternalName Unique
uniq (Name { n_occ :: Name -> OccName
n_occ = OccName
occ, n_loc :: Name -> SrcSpan
n_loc = SrcSpan
loc })
  = Name { n_uniq :: Unique
n_uniq = Unique
uniq, n_sort :: NameSort
n_sort = NameSort
Internal
         , n_occ :: OccName
n_occ = OccName
occ, n_loc :: SrcSpan
n_loc = SrcSpan
loc }

mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName OccName -> OccName
derive_occ Unique
uniq (Name { n_occ :: Name -> OccName
n_occ = OccName
occ, n_loc :: Name -> SrcSpan
n_loc = SrcSpan
loc })
  = Name { n_uniq :: Unique
n_uniq = Unique
uniq, n_sort :: NameSort
n_sort = NameSort
Internal
         , n_occ :: OccName
n_occ = OccName -> OccName
derive_occ OccName
occ, n_loc :: SrcSpan
n_loc = SrcSpan
loc }

-- | Create a name which definitely originates in the given module
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
{-# INLINE mkExternalName #-}
-- WATCH OUT! External Names should be in the Name Cache
-- (see Note [The Name Cache] in GHC.Iface.Env), so don't just call mkExternalName
-- with some fresh unique without populating the Name Cache
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
mkExternalName Unique
uniq Module
mod OccName
occ SrcSpan
loc
  = Name { n_uniq :: Unique
n_uniq = Unique
uniq, n_sort :: NameSort
n_sort = Module -> NameSort
External Module
mod,
           n_occ :: OccName
n_occ = OccName
occ, n_loc :: SrcSpan
n_loc = SrcSpan
loc }

-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
{-# INLINE mkWiredInName #-}
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
mkWiredInName Module
mod OccName
occ Unique
uniq TyThing
thing BuiltInSyntax
built_in
  = Name { n_uniq :: Unique
n_uniq = Unique
uniq,
           n_sort :: NameSort
n_sort = Module -> TyThing -> BuiltInSyntax -> NameSort
WiredIn Module
mod TyThing
thing BuiltInSyntax
built_in,
           n_occ :: OccName
n_occ = OccName
occ, n_loc :: SrcSpan
n_loc = SrcSpan
wiredInSrcSpan }

-- | Create a name brought into being by the compiler
mkSystemName :: Unique -> OccName -> Name
mkSystemName :: Unique -> OccName -> Name
mkSystemName Unique
uniq OccName
occ = Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt Unique
uniq OccName
occ SrcSpan
noSrcSpan

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt Unique
uniq OccName
occ SrcSpan
loc = Name { n_uniq :: Unique
n_uniq = Unique
uniq, n_sort :: NameSort
n_sort = NameSort
System
                                   , n_occ :: OccName
n_occ = OccName
occ, n_loc :: SrcSpan
n_loc = SrcSpan
loc }

mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName Unique
uniq FastString
fs = Unique -> OccName -> Name
mkSystemName Unique
uniq (FastString -> OccName
mkVarOccFS FastString
fs)

mkSysTvName :: Unique -> FastString -> Name
mkSysTvName :: Unique -> FastString -> Name
mkSysTvName Unique
uniq FastString
fs = Unique -> OccName -> Name
mkSystemName Unique
uniq (FastString -> OccName
mkTyVarOccFS FastString
fs)

-- | Make a name for a foreign call
mkFCallName :: Unique -> String -> Name
mkFCallName :: Unique -> String -> Name
mkFCallName Unique
uniq String
str = Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq (String -> OccName
mkVarOcc String
str) SrcSpan
noSrcSpan
   -- The encoded string completely describes the ccall

-- When we renumber/rename things, we need to be
-- able to change a Name's Unique to match the cached
-- one in the thing it's the name of.  If you know what I mean.
setNameUnique :: Name -> Unique -> Name
setNameUnique :: Name -> Unique -> Name
setNameUnique Name
name Unique
uniq = Name
name {n_uniq :: Unique
n_uniq = Unique
uniq}

-- This is used for hsigs: we want to use the name of the originally exported
-- entity, but edit the location to refer to the reexport site
setNameLoc :: Name -> SrcSpan -> Name
setNameLoc :: Name -> SrcSpan -> Name
setNameLoc Name
name SrcSpan
loc = Name
name {n_loc :: SrcSpan
n_loc = SrcSpan
loc}

tidyNameOcc :: Name -> OccName -> Name
-- We set the OccName of a Name when tidying
-- In doing so, we change System --> Internal, so that when we print
-- it we don't get the unique by default.  It's tidy now!
tidyNameOcc :: Name -> OccName -> Name
tidyNameOcc name :: Name
name@(Name { n_sort :: Name -> NameSort
n_sort = NameSort
System }) OccName
occ = Name
name { n_occ :: OccName
n_occ = OccName
occ, n_sort :: NameSort
n_sort = NameSort
Internal}
tidyNameOcc Name
name                            OccName
occ = Name
name { n_occ :: OccName
n_occ = OccName
occ }

-- | Make the 'Name' into an internal name, regardless of what it was to begin with
localiseName :: Name -> Name
localiseName :: Name -> Name
localiseName Name
n = Name
n { n_sort :: NameSort
n_sort = NameSort
Internal }

{-
************************************************************************
*                                                                      *
\subsection{Hashing and comparison}
*                                                                      *
************************************************************************
-}

cmpName :: Name -> Name -> Ordering
cmpName :: Name -> Name -> Ordering
cmpName Name
n1 Name
n2 = Name -> Unique
n_uniq Name
n1 Unique -> Unique -> Ordering
`nonDetCmpUnique` Name -> Unique
n_uniq Name
n2

-- | Compare Names lexicographically
-- This only works for Names that originate in the source code or have been
-- tidied.
stableNameCmp :: Name -> Name -> Ordering
stableNameCmp :: Name -> Name -> Ordering
stableNameCmp (Name { n_sort :: Name -> NameSort
n_sort = NameSort
s1, n_occ :: Name -> OccName
n_occ = OccName
occ1 })
              (Name { n_sort :: Name -> NameSort
n_sort = NameSort
s2, n_occ :: Name -> OccName
n_occ = OccName
occ2 })
  = (NameSort
s1 NameSort -> NameSort -> Ordering
`sort_cmp` NameSort
s2) Ordering -> Ordering -> Ordering
`thenCmp` (OccName
occ1 forall a. Ord a => a -> a -> Ordering
`compare` OccName
occ2)
    -- The ordinary compare on OccNames is lexicographic
  where
    -- Later constructors are bigger
    sort_cmp :: NameSort -> NameSort -> Ordering
sort_cmp (External Module
m1) (External Module
m2)       = Module
m1 Module -> Module -> Ordering
`stableModuleCmp` Module
m2
    sort_cmp (External {}) NameSort
_                   = Ordering
LT
    sort_cmp (WiredIn {}) (External {})        = Ordering
GT
    sort_cmp (WiredIn Module
m1 TyThing
_ BuiltInSyntax
_) (WiredIn Module
m2 TyThing
_ BuiltInSyntax
_) = Module
m1 Module -> Module -> Ordering
`stableModuleCmp` Module
m2
    sort_cmp (WiredIn {})     NameSort
_                = Ordering
LT
    sort_cmp NameSort
Internal         (External {})    = Ordering
GT
    sort_cmp NameSort
Internal         (WiredIn {})     = Ordering
GT
    sort_cmp NameSort
Internal         NameSort
Internal         = Ordering
EQ
    sort_cmp NameSort
Internal         NameSort
System           = Ordering
LT
    sort_cmp NameSort
System           NameSort
System           = Ordering
EQ
    sort_cmp NameSort
System           NameSort
_                = Ordering
GT

{-
************************************************************************
*                                                                      *
\subsection[Name-instances]{Instance declarations}
*                                                                      *
************************************************************************
-}

-- | The same comments as for `Name`'s `Ord` instance apply.
instance Eq Name where
    Name
a == :: Name -> Name -> Bool
== Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
EQ -> Bool
True;  Ordering
_ -> Bool
False }
    Name
a /= :: Name -> Name -> Bool
/= Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
EQ -> Bool
False; Ordering
_ -> Bool
True }

-- | __Caution__: This instance is implemented via `nonDetCmpUnique`, which
-- means that the ordering is not stable across deserialization or rebuilds.
--
-- See `nonDetCmpUnique` for further information, and trac #15240 for a bug
-- caused by improper use of this instance.

-- For a deterministic lexicographic ordering, use `stableNameCmp`.
instance Ord Name where
    Name
a <= :: Name -> Name -> Bool
<= Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
LT -> Bool
True;  Ordering
EQ -> Bool
True;  Ordering
GT -> Bool
False }
    Name
a < :: Name -> Name -> Bool
<  Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
LT -> Bool
True;  Ordering
EQ -> Bool
False; Ordering
GT -> Bool
False }
    Name
a >= :: Name -> Name -> Bool
>= Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
LT -> Bool
False; Ordering
EQ -> Bool
True;  Ordering
GT -> Bool
True  }
    Name
a > :: Name -> Name -> Bool
>  Name
b = case (Name
a forall a. Ord a => a -> a -> Ordering
`compare` Name
b) of { Ordering
LT -> Bool
False; Ordering
EQ -> Bool
False; Ordering
GT -> Bool
True  }
    compare :: Name -> Name -> Ordering
compare Name
a Name
b = Name -> Name -> Ordering
cmpName Name
a Name
b

instance Uniquable Name where
    getUnique :: Name -> Unique
getUnique = Name -> Unique
nameUnique

instance NamedThing Name where
    getName :: Name -> Name
getName Name
n = Name
n

instance Data Name where
  -- don't traverse?
  toConstr :: Name -> Constr
toConstr Name
_   = String -> Constr
abstractConstr String
"Name"
  gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gunfold forall b r. Data b => c (b -> r) -> c r
_ forall r. r -> c r
_  = forall a. HasCallStack => String -> a
error String
"gunfold"
  dataTypeOf :: Name -> DataType
dataTypeOf Name
_ = String -> DataType
mkNoRepType String
"Name"

{-
************************************************************************
*                                                                      *
\subsection{Binary}
*                                                                      *
************************************************************************
-}

-- | Assumes that the 'Name' is a non-binding one. See
-- 'GHC.Iface.Syntax.putIfaceTopBndr' and 'GHC.Iface.Syntax.getIfaceTopBndr' for
-- serializing binding 'Name's. See 'UserData' for the rationale for this
-- distinction.
instance Binary Name where
   put_ :: BinHandle -> Name -> IO ()
put_ BinHandle
bh Name
name =
      case BinHandle -> UserData
getUserData BinHandle
bh of
        UserData{ ud_put_nonbinding_name :: UserData -> BinHandle -> Name -> IO ()
ud_put_nonbinding_name = BinHandle -> Name -> IO ()
put_name } -> BinHandle -> Name -> IO ()
put_name BinHandle
bh Name
name

   get :: BinHandle -> IO Name
get BinHandle
bh =
      case BinHandle -> UserData
getUserData BinHandle
bh of
        UserData { ud_get_name :: UserData -> BinHandle -> IO Name
ud_get_name = BinHandle -> IO Name
get_name } -> BinHandle -> IO Name
get_name BinHandle
bh

{-
************************************************************************
*                                                                      *
\subsection{Pretty printing}
*                                                                      *
************************************************************************
-}

instance Outputable Name where
    ppr :: Name -> SDoc
ppr Name
name = Name -> SDoc
pprName Name
name

instance OutputableBndr Name where
    pprBndr :: BindingSite -> Name -> SDoc
pprBndr BindingSite
_ Name
name = Name -> SDoc
pprName Name
name
    pprInfixOcc :: Name -> SDoc
pprInfixOcc  = forall a. (Outputable a, NamedThing a) => a -> SDoc
pprInfixName
    pprPrefixOcc :: Name -> SDoc
pprPrefixOcc = forall a. NamedThing a => a -> SDoc
pprPrefixName

pprName :: Name -> SDoc
pprName :: Name -> SDoc
pprName (Name {n_sort :: Name -> NameSort
n_sort = NameSort
sort, n_uniq :: Name -> Unique
n_uniq = Unique
uniq, n_occ :: Name -> OccName
n_occ = OccName
occ})
  = (PprStyle -> SDoc) -> SDoc
getPprStyle forall a b. (a -> b) -> a -> b
$ \PprStyle
sty ->
    (Bool -> SDoc) -> SDoc
getPprDebug forall a b. (a -> b) -> a -> b
$ \Bool
debug ->
    case NameSort
sort of
      WiredIn Module
mod TyThing
_ BuiltInSyntax
builtin   -> Bool
-> PprStyle
-> Unique
-> Module
-> OccName
-> Bool
-> BuiltInSyntax
-> SDoc
pprExternal Bool
debug PprStyle
sty Unique
uniq Module
mod OccName
occ Bool
True  BuiltInSyntax
builtin
      External Module
mod            -> Bool
-> PprStyle
-> Unique
-> Module
-> OccName
-> Bool
-> BuiltInSyntax
-> SDoc
pprExternal Bool
debug PprStyle
sty Unique
uniq Module
mod OccName
occ Bool
False BuiltInSyntax
UserSyntax
      NameSort
System                  -> Bool -> PprStyle -> Unique -> OccName -> SDoc
pprSystem   Bool
debug PprStyle
sty Unique
uniq OccName
occ
      NameSort
Internal                -> Bool -> PprStyle -> Unique -> OccName -> SDoc
pprInternal Bool
debug PprStyle
sty Unique
uniq OccName
occ

-- | Print the string of Name unqualifiedly directly.
pprNameUnqualified :: Name -> SDoc
pprNameUnqualified :: Name -> SDoc
pprNameUnqualified Name { n_occ :: Name -> OccName
n_occ = OccName
occ } = OccName -> SDoc
ppr_occ_name OccName
occ

pprExternal :: Bool -> PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
pprExternal :: Bool
-> PprStyle
-> Unique
-> Module
-> OccName
-> Bool
-> BuiltInSyntax
-> SDoc
pprExternal Bool
debug PprStyle
sty Unique
uniq Module
mod OccName
occ Bool
is_wired BuiltInSyntax
is_builtin
  | PprStyle -> Bool
codeStyle PprStyle
sty = forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> Char -> SDoc
char Char
'_' SDoc -> SDoc -> SDoc
<> OccName -> SDoc
ppr_z_occ_name OccName
occ
        -- In code style, always qualify
        -- ToDo: maybe we could print all wired-in things unqualified
        --       in code style, to reduce symbol table bloat?
  | Bool
debug         = SDoc
pp_mod SDoc -> SDoc -> SDoc
<> OccName -> SDoc
ppr_occ_name OccName
occ
                     SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces ([SDoc] -> SDoc
hsep [if Bool
is_wired then String -> SDoc
text String
"(w)" else SDoc
empty,
                                      NameSpace -> SDoc
pprNameSpaceBrief (OccName -> NameSpace
occNameSpace OccName
occ),
                                      Unique -> SDoc
pprUnique Unique
uniq])
  | BuiltInSyntax
BuiltInSyntax <- BuiltInSyntax
is_builtin = OccName -> SDoc
ppr_occ_name OccName
occ  -- Never qualify builtin syntax
  | Bool
otherwise                   =
        if forall u. GenModule (GenUnit u) -> Bool
isHoleModule Module
mod
            then case PprStyle -> QueryQualifyName
qualName PprStyle
sty Module
mod OccName
occ of
                    QualifyName
NameUnqual -> OccName -> SDoc
ppr_occ_name OccName
occ
                    QualifyName
_ -> SDoc -> SDoc
braces (forall a. Outputable a => a -> SDoc
ppr (forall unit. GenModule unit -> ModuleName
moduleName Module
mod) SDoc -> SDoc -> SDoc
<> SDoc
dot SDoc -> SDoc -> SDoc
<> OccName -> SDoc
ppr_occ_name OccName
occ)
            else PprStyle -> Module -> OccName -> SDoc
pprModulePrefix PprStyle
sty Module
mod OccName
occ SDoc -> SDoc -> SDoc
<> OccName -> SDoc
ppr_occ_name OccName
occ
  where
    pp_mod :: SDoc
pp_mod = (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption SDocContext -> Bool
sdocSuppressModulePrefixes
               (forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> SDoc
dot)

pprInternal :: Bool -> PprStyle -> Unique -> OccName -> SDoc
pprInternal :: Bool -> PprStyle -> Unique -> OccName -> SDoc
pprInternal Bool
debug PprStyle
sty Unique
uniq OccName
occ
  | PprStyle -> Bool
codeStyle PprStyle
sty  = Unique -> SDoc
pprUniqueAlways Unique
uniq
  | Bool
debug          = OccName -> SDoc
ppr_occ_name OccName
occ SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces ([SDoc] -> SDoc
hsep [NameSpace -> SDoc
pprNameSpaceBrief (OccName -> NameSpace
occNameSpace OccName
occ),
                                                       Unique -> SDoc
pprUnique Unique
uniq])
  | PprStyle -> Bool
dumpStyle PprStyle
sty  = OccName -> SDoc
ppr_occ_name OccName
occ SDoc -> SDoc -> SDoc
<> Unique -> SDoc
ppr_underscore_unique Unique
uniq
                        -- For debug dumps, we're not necessarily dumping
                        -- tidied code, so we need to print the uniques.
  | Bool
otherwise      = OccName -> SDoc
ppr_occ_name OccName
occ   -- User style

-- Like Internal, except that we only omit the unique in Iface style
pprSystem :: Bool -> PprStyle -> Unique -> OccName -> SDoc
pprSystem :: Bool -> PprStyle -> Unique -> OccName -> SDoc
pprSystem Bool
debug PprStyle
sty Unique
uniq OccName
occ
  | PprStyle -> Bool
codeStyle PprStyle
sty  = Unique -> SDoc
pprUniqueAlways Unique
uniq
  | Bool
debug          = OccName -> SDoc
ppr_occ_name OccName
occ SDoc -> SDoc -> SDoc
<> Unique -> SDoc
ppr_underscore_unique Unique
uniq
                     SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces (NameSpace -> SDoc
pprNameSpaceBrief (OccName -> NameSpace
occNameSpace OccName
occ))
  | Bool
otherwise      = OccName -> SDoc
ppr_occ_name OccName
occ SDoc -> SDoc -> SDoc
<> Unique -> SDoc
ppr_underscore_unique Unique
uniq
                                -- If the tidy phase hasn't run, the OccName
                                -- is unlikely to be informative (like 's'),
                                -- so print the unique


pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in GHC.Types.Name.Ppr
pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
pprModulePrefix PprStyle
sty Module
mod OccName
occ = (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption SDocContext -> Bool
sdocSuppressModulePrefixes forall a b. (a -> b) -> a -> b
$
    case PprStyle -> QueryQualifyName
qualName PprStyle
sty Module
mod OccName
occ of              -- See Outputable.QualifyName:
      NameQual ModuleName
modname -> forall a. Outputable a => a -> SDoc
ppr ModuleName
modname SDoc -> SDoc -> SDoc
<> SDoc
dot       -- Name is in scope
      QualifyName
NameNotInScope1  -> forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> SDoc
dot           -- Not in scope
      QualifyName
NameNotInScope2  -> forall a. Outputable a => a -> SDoc
ppr (forall unit. GenModule unit -> unit
moduleUnit Module
mod) SDoc -> SDoc -> SDoc
<> SDoc
colon     -- Module not in
                          SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr (forall unit. GenModule unit -> ModuleName
moduleName Module
mod) SDoc -> SDoc -> SDoc
<> SDoc
dot          -- scope either
      QualifyName
NameUnqual       -> SDoc
empty                   -- In scope unqualified

pprUnique :: Unique -> SDoc
-- Print a unique unless we are suppressing them
pprUnique :: Unique -> SDoc
pprUnique Unique
uniq
  = (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption SDocContext -> Bool
sdocSuppressUniques forall a b. (a -> b) -> a -> b
$
      Unique -> SDoc
pprUniqueAlways Unique
uniq

ppr_underscore_unique :: Unique -> SDoc
-- Print an underscore separating the name from its unique
-- But suppress it if we aren't printing the uniques anyway
ppr_underscore_unique :: Unique -> SDoc
ppr_underscore_unique Unique
uniq
  = (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption SDocContext -> Bool
sdocSuppressUniques forall a b. (a -> b) -> a -> b
$
      Char -> SDoc
char Char
'_' SDoc -> SDoc -> SDoc
<> Unique -> SDoc
pprUniqueAlways Unique
uniq

ppr_occ_name :: OccName -> SDoc
ppr_occ_name :: OccName -> SDoc
ppr_occ_name OccName
occ = FastString -> SDoc
ftext (OccName -> FastString
occNameFS OccName
occ)
        -- Don't use pprOccName; instead, just print the string of the OccName;
        -- we print the namespace in the debug stuff above

-- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
-- cached behind the scenes in the FastString implementation.
ppr_z_occ_name :: OccName -> SDoc
ppr_z_occ_name :: OccName -> SDoc
ppr_z_occ_name OccName
occ = FastZString -> SDoc
ztext (FastString -> FastZString
zEncodeFS (OccName -> FastString
occNameFS OccName
occ))

-- Prints (if mod information is available) "Defined at <loc>" or
--  "Defined in <mod>" information for a Name.
pprDefinedAt :: Name -> SDoc
pprDefinedAt :: Name -> SDoc
pprDefinedAt Name
name = String -> SDoc
text String
"Defined" SDoc -> SDoc -> SDoc
<+> Name -> SDoc
pprNameDefnLoc Name
name

pprNameDefnLoc :: Name -> SDoc
-- Prints "at <loc>" or
--     or "in <mod>" depending on what info is available
pprNameDefnLoc :: Name -> SDoc
pprNameDefnLoc Name
name
  = case Name -> SrcLoc
nameSrcLoc Name
name of
         -- nameSrcLoc rather than nameSrcSpan
         -- It seems less cluttered to show a location
         -- rather than a span for the definition point
       RealSrcLoc RealSrcLoc
s Maybe BufPos
_ -> String -> SDoc
text String
"at" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr RealSrcLoc
s
       UnhelpfulLoc FastString
s
         | Name -> Bool
isInternalName Name
name Bool -> Bool -> Bool
|| Name -> Bool
isSystemName Name
name
         -> String -> SDoc
text String
"at" SDoc -> SDoc -> SDoc
<+> FastString -> SDoc
ftext FastString
s
         | Bool
otherwise
         -> String -> SDoc
text String
"in" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr (HasDebugCallStack => Name -> Module
nameModule Name
name))


-- | Get a string representation of a 'Name' that's unique and stable
-- across recompilations. Used for deterministic generation of binds for
-- derived instances.
-- eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"
nameStableString :: Name -> String
nameStableString :: Name -> String
nameStableString Name{OccName
Unique
SrcSpan
NameSort
n_loc :: SrcSpan
n_uniq :: Unique
n_occ :: OccName
n_sort :: NameSort
n_loc :: Name -> SrcSpan
n_uniq :: Name -> Unique
n_occ :: Name -> OccName
n_sort :: Name -> NameSort
..} =
  NameSort -> String
nameSortStableString NameSort
n_sort forall a. [a] -> [a] -> [a]
++ String
"$" forall a. [a] -> [a] -> [a]
++ OccName -> String
occNameString OccName
n_occ

nameSortStableString :: NameSort -> String
nameSortStableString :: NameSort -> String
nameSortStableString NameSort
System = String
"$_sys"
nameSortStableString NameSort
Internal = String
"$_in"
nameSortStableString (External Module
mod) = Module -> String
moduleStableString Module
mod
nameSortStableString (WiredIn Module
mod TyThing
_ BuiltInSyntax
_) = Module -> String
moduleStableString Module
mod

{-
************************************************************************
*                                                                      *
\subsection{Overloaded functions related to Names}
*                                                                      *
************************************************************************
-}

-- | A class allowing convenient access to the 'Name' of various datatypes
class NamedThing a where
    getOccName :: a -> OccName
    getName    :: a -> Name

    getOccName a
n = Name -> OccName
nameOccName (forall a. NamedThing a => a -> Name
getName a
n)      -- Default method

instance NamedThing e => NamedThing (Located e) where
    getName :: Located e -> Name
getName = forall a. NamedThing a => a -> Name
getName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> e
unLoc

getSrcLoc           :: NamedThing a => a -> SrcLoc
getSrcSpan          :: NamedThing a => a -> SrcSpan
getOccString        :: NamedThing a => a -> String
getOccFS            :: NamedThing a => a -> FastString

getSrcLoc :: forall a. NamedThing a => a -> SrcLoc
getSrcLoc           = Name -> SrcLoc
nameSrcLoc           forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NamedThing a => a -> Name
getName
getSrcSpan :: forall a. NamedThing a => a -> SrcSpan
getSrcSpan          = Name -> SrcSpan
nameSrcSpan          forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NamedThing a => a -> Name
getName
getOccString :: forall a. NamedThing a => a -> String
getOccString        = OccName -> String
occNameString        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NamedThing a => a -> OccName
getOccName
getOccFS :: forall a. NamedThing a => a -> FastString
getOccFS            = OccName -> FastString
occNameFS            forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NamedThing a => a -> OccName
getOccName

pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
-- See Outputable.pprPrefixVar, pprInfixVar;
-- add parens or back-quotes as appropriate
pprInfixName :: forall a. (Outputable a, NamedThing a) => a -> SDoc
pprInfixName  a
n = Bool -> SDoc -> SDoc
pprInfixVar (OccName -> Bool
isSymOcc (forall a. NamedThing a => a -> OccName
getOccName a
n)) (forall a. Outputable a => a -> SDoc
ppr a
n)

pprPrefixName :: NamedThing a => a -> SDoc
pprPrefixName :: forall a. NamedThing a => a -> SDoc
pprPrefixName a
thing = Bool -> SDoc -> SDoc
pprPrefixVar (OccName -> Bool
isSymOcc (Name -> OccName
nameOccName Name
name)) (forall a. Outputable a => a -> SDoc
ppr Name
name)
 where
   name :: Name
name = forall a. NamedThing a => a -> Name
getName a
thing