{-
(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}
-}

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

-- |
-- #name_types#
-- GHC uses several kinds of name internally:
--
-- * 'OccName.OccName': see "OccName#name_types"
--
-- * 'RdrName.RdrName': see "RdrName#name_types"
--
-- *  'Name.Name' is the type of names that have had their scoping and binding resolved. They
--   have an 'OccName.OccName' but also a 'Unique.Unique' that disambiguates Names that have
--   the same 'OccName.OccName' and indeed is used for all 'Name.Name' comparison. Names
--   also contain information about where they originated from, see "Name#name_sorts"
--
-- * 'Id.Id': see "Id#name_types"
--
-- * 'Var.Var': see "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 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, nameModule, nameModule_maybe,
        setNameLoc,
        tidyNameOcc,
        localiseName,

        nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,

        -- ** Predicates on 'Name's
        isSystemName, isInternalName, isExternalName,
        isTyVarName, isTyConName, isDataConName,
        isValName, isVarName,
        isWiredInName, 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 OccName
    ) where

import GhcPrelude

import {-# SOURCE #-} TyCoRep( TyThing )

import OccName
import Module
import SrcLoc
import Unique
import Util
import Maybes
import Binary
import DynFlags
import FastString
import Outputable

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
                Name -> Unique
n_uniq :: {-# UNPACK #-} !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 _)    = String -> SDoc
text "external"
  ppr (WiredIn _ _ _) = String -> SDoc
text "wired-in"
  ppr  Internal       = String -> SDoc
text "internal"
  ppr  System         = String -> SDoc
text "system"

instance NFData Name where
  rnf :: Name -> ()
rnf Name{..} = NameSort -> ()
forall a. NFData a => a -> ()
rnf NameSort
n_sort

instance NFData NameSort where
  rnf :: NameSort -> ()
rnf (External m :: Module
m) = Module -> ()
forall a. NFData a => a -> ()
rnf Module
m
  rnf (WiredIn m :: Module
m t :: TyThing
t b :: BuiltInSyntax
b) = Module -> ()
forall a. NFData a => a -> ()
rnf Module
m () -> () -> ()
forall a b. a -> b -> b
`seq` TyThing
t TyThing -> () -> ()
forall a b. a -> b -> b
`seq` BuiltInSyntax
b BuiltInSyntax -> () -> ()
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 Internal = ()
  rnf 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 [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 IfaceEnv.

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
nameModule              :: HasDebugCallStack => Name -> Module
nameSrcLoc              :: Name -> SrcLoc
nameSrcSpan             :: Name -> SrcSpan

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

type instance SrcSpanLess Name = Name
instance HasSrcSpan Name where
  composeSrcSpan :: Located (SrcSpanLess Name) -> Name
composeSrcSpan   (L sp :: SrcSpan
sp  n :: SrcSpanLess Name
n) = Name
SrcSpanLess Name
n {n_loc :: SrcSpan
n_loc = SrcSpan
sp}
  decomposeSrcSpan :: Name -> Located (SrcSpanLess Name)
decomposeSrcSpan n :: Name
n         = SrcSpan -> Name -> GenLocated SrcSpan Name
forall l e. l -> e -> GenLocated l e
L (Name -> SrcSpan
n_loc Name
n) Name
n


{-
************************************************************************
*                                                                      *
\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 _ _ _}) = Bool
True
isWiredInName _                               = Bool
False

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

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

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

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

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

nameModule :: Name -> Module
nameModule name :: Name
name =
  Name -> Maybe Module
nameModule_maybe Name
name Maybe Module -> Module -> Module
forall a. Maybe a -> a -> a
`orElse`
  String -> SDoc -> Module
forall a. HasCallStack => String -> SDoc -> a
pprPanic "nameModule" (NameSort -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Name -> NameSort
n_sort Name
name) SDoc -> SDoc -> SDoc
<+> Name -> 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 mod :: Module
mod})    = Module -> Maybe Module
forall a. a -> Maybe a
Just Module
mod
nameModule_maybe (Name { n_sort :: Name -> NameSort
n_sort = WiredIn mod :: Module
mod _ _}) = Module -> Maybe Module
forall a. a -> Maybe a
Just Module
mod
nameModule_maybe _                                  = Maybe Module
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 HscTypes

nameIsLocalOrFrom :: Module -> Name -> Bool
nameIsLocalOrFrom from :: Module
from name :: Name
name
  | Just mod :: Module
mod <- Name -> Maybe Module
nameModule_maybe Name
name = Module
from Module -> Module -> Bool
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 this_mod :: Module
this_mod
  = \nm :: Name
nm -> case Name -> NameSort
n_sort Name
nm of
              External nm_mod :: Module
nm_mod    -> Module -> UnitId
moduleUnitId Module
nm_mod UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== UnitId
this_pkg
              WiredIn nm_mod :: Module
nm_mod _ _ -> Module -> UnitId
moduleUnitId Module
nm_mod UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== UnitId
this_pkg
              Internal -> Bool
True
              System   -> Bool
False
  where
    this_pkg :: UnitId
this_pkg = Module -> UnitId
moduleUnitId 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 this_mod :: Module
this_mod
  = \nm :: Name
nm -> case Name -> Maybe Module
nameModule_maybe Name
nm of
              Nothing -> Bool
False
              Just nm_mod :: Module
nm_mod -> Module
nm_mod Module -> Module -> Bool
forall a. Eq a => a -> a -> Bool
/= Module
this_mod
                          Bool -> Bool -> Bool
&& Module -> UnitId
moduleUnitId Module
nm_mod UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== UnitId
this_pkg
  where
    this_pkg :: UnitId
this_pkg = Module -> UnitId
moduleUnitId Module
this_mod

-- | Returns True if the Name comes from some other package: neither this
-- package nor the interactive package.
nameIsFromExternalPackage :: UnitId -> Name -> Bool
nameIsFromExternalPackage :: UnitId -> Name -> Bool
nameIsFromExternalPackage this_pkg :: UnitId
this_pkg name :: Name
name
  | Just mod :: Module
mod <- Name -> Maybe Module
nameModule_maybe Name
name
  , Module -> UnitId
moduleUnitId Module
mod UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
/= UnitId
this_pkg    -- Not this package
  , 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
name = OccName -> Bool
isTvOcc (Name -> OccName
nameOccName Name
name)

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

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

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

isVarName :: Name -> Bool
isVarName :: Name -> Bool
isVarName = OccName -> Bool
isVarOcc (OccName -> Bool) -> (Name -> OccName) -> Name -> Bool
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 _                        = 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 uniq :: Unique
uniq occ :: OccName
occ loc :: SrcSpan
loc = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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 uniq :: Unique
uniq (Name { n_occ :: Name -> OccName
n_occ = OccName
occ, n_loc :: Name -> SrcSpan
n_loc = SrcSpan
loc })
  = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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 derive_occ :: OccName -> OccName
derive_occ uniq :: Unique
uniq (Name { n_occ :: Name -> OccName
n_occ = OccName
occ, n_loc :: Name -> SrcSpan
n_loc = SrcSpan
loc })
  = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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
-- WATCH OUT! External Names should be in the Name Cache
-- (see Note [The Name Cache] in IfaceEnv), so don't just call mkExternalName
-- with some fresh unique without populating the Name Cache
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
mkExternalName uniq :: Unique
uniq mod :: Module
mod occ :: OccName
occ loc :: SrcSpan
loc
  = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
mkWiredInName mod :: Module
mod occ :: OccName
occ uniq :: Unique
uniq thing :: TyThing
thing built_in :: BuiltInSyntax
built_in
  = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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 uniq :: Unique
uniq occ :: OccName
occ = Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt Unique
uniq OccName
occ SrcSpan
noSrcSpan

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt uniq :: Unique
uniq occ :: OccName
occ loc :: SrcSpan
loc = $WName :: NameSort -> OccName -> Unique -> SrcSpan -> Name
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 uniq :: Unique
uniq fs :: FastString
fs = Unique -> OccName -> Name
mkSystemName Unique
uniq (FastString -> OccName
mkVarOccFS FastString
fs)

mkSysTvName :: Unique -> FastString -> Name
mkSysTvName :: Unique -> FastString -> Name
mkSysTvName uniq :: Unique
uniq fs :: 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 uniq :: Unique
uniq str :: 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
name uniq :: 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
name loc :: 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 }) occ :: OccName
occ = Name
name { n_occ :: OccName
n_occ = OccName
occ, n_sort :: NameSort
n_sort = NameSort
Internal}
tidyNameOcc name :: Name
name                            occ :: 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 n :: Name
n = Name
n { n_sort :: NameSort
n_sort = NameSort
Internal }

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

cmpName :: Name -> Name -> Ordering
cmpName :: Name -> Name -> Ordering
cmpName n1 :: Name
n1 n2 :: 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 OccName -> OccName -> Ordering
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 m1 :: Module
m1) (External m2 :: Module
m2)       = Module
m1 Module -> Module -> Ordering
`stableModuleCmp` Module
m2
    sort_cmp (External {}) _                   = Ordering
LT
    sort_cmp (WiredIn {}) (External {})        = Ordering
GT
    sort_cmp (WiredIn m1 :: Module
m1 _ _) (WiredIn m2 :: Module
m2 _ _) = Module
m1 Module -> Module -> Ordering
`stableModuleCmp` Module
m2
    sort_cmp (WiredIn {})     _                = Ordering
LT
    sort_cmp Internal         (External {})    = Ordering
GT
    sort_cmp Internal         (WiredIn {})     = Ordering
GT
    sort_cmp Internal         Internal         = Ordering
EQ
    sort_cmp Internal         System           = Ordering
LT
    sort_cmp System           System           = Ordering
EQ
    sort_cmp System           _                = Ordering
GT

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

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

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

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

-- | Assumes that the 'Name' is a non-binding one. See
-- 'IfaceSyn.putIfaceTopBndr' and 'IfaceSyn.getIfaceTopBndr' for serializing
-- binding 'Name's. See 'UserData' for the rationale for this distinction.
instance Binary Name where
   put_ :: BinHandle -> Name -> IO ()
put_ bh :: BinHandle
bh name :: 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 bh :: 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 = Name -> SDoc
pprName Name
name

instance OutputableBndr Name where
    pprBndr :: BindingSite -> Name -> SDoc
pprBndr _ name :: Name
name = Name -> SDoc
pprName Name
name
    pprInfixOcc :: Name -> SDoc
pprInfixOcc  = Name -> SDoc
forall a. (Outputable a, NamedThing a) => a -> SDoc
pprInfixName
    pprPrefixOcc :: Name -> SDoc
pprPrefixOcc = Name -> SDoc
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 ((PprStyle -> SDoc) -> SDoc) -> (PprStyle -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \ sty :: PprStyle
sty ->
    case NameSort
sort of
      WiredIn mod :: Module
mod _ builtin :: BuiltInSyntax
builtin   -> PprStyle
-> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
pprExternal PprStyle
sty Unique
uniq Module
mod OccName
occ Bool
True  BuiltInSyntax
builtin
      External mod :: Module
mod            -> PprStyle
-> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
pprExternal PprStyle
sty Unique
uniq Module
mod OccName
occ Bool
False BuiltInSyntax
UserSyntax
      System                  -> PprStyle -> Unique -> OccName -> SDoc
pprSystem PprStyle
sty Unique
uniq OccName
occ
      Internal                -> PprStyle -> Unique -> OccName -> SDoc
pprInternal 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 :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
pprExternal :: PprStyle
-> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
pprExternal sty :: PprStyle
sty uniq :: Unique
uniq mod :: Module
mod occ :: OccName
occ is_wired :: Bool
is_wired is_builtin :: BuiltInSyntax
is_builtin
  | PprStyle -> Bool
codeStyle PprStyle
sty = Module -> SDoc
forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> Char -> SDoc
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?
  | PprStyle -> Bool
debugStyle PprStyle
sty = 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 "(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 Module -> Bool
isHoleModule Module
mod
            then case PprStyle -> QueryQualifyName
qualName PprStyle
sty Module
mod OccName
occ of
                    NameUnqual -> OccName -> SDoc
ppr_occ_name OccName
occ
                    _ -> SDoc -> SDoc
braces (ModuleName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Module -> 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 = (DynFlags -> SDoc) -> SDoc
sdocWithDynFlags ((DynFlags -> SDoc) -> SDoc) -> (DynFlags -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \dflags :: DynFlags
dflags ->
             if GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressModulePrefixes DynFlags
dflags
             then SDoc
empty
             else Module -> SDoc
forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> SDoc
dot

pprInternal :: PprStyle -> Unique -> OccName -> SDoc
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
pprInternal sty :: PprStyle
sty uniq :: Unique
uniq occ :: OccName
occ
  | PprStyle -> Bool
codeStyle PprStyle
sty  = Unique -> SDoc
pprUniqueAlways Unique
uniq
  | PprStyle -> Bool
debugStyle PprStyle
sty = 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 :: PprStyle -> Unique -> OccName -> SDoc
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
pprSystem sty :: PprStyle
sty uniq :: Unique
uniq occ :: OccName
occ
  | PprStyle -> Bool
codeStyle PprStyle
sty  = Unique -> SDoc
pprUniqueAlways Unique
uniq
  | PprStyle -> Bool
debugStyle PprStyle
sty = 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 HscTypes
pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
pprModulePrefix sty :: PprStyle
sty mod :: Module
mod occ :: OccName
occ = (DynFlags -> SDoc) -> SDoc
sdocWithDynFlags ((DynFlags -> SDoc) -> SDoc) -> (DynFlags -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \dflags :: DynFlags
dflags ->
  if GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressModulePrefixes DynFlags
dflags
  then SDoc
empty
  else
    case PprStyle -> QueryQualifyName
qualName PprStyle
sty Module
mod OccName
occ of              -- See Outputable.QualifyName:
      NameQual modname :: ModuleName
modname -> ModuleName -> SDoc
forall a. Outputable a => a -> SDoc
ppr ModuleName
modname SDoc -> SDoc -> SDoc
<> SDoc
dot       -- Name is in scope
      NameNotInScope1  -> Module -> SDoc
forall a. Outputable a => a -> SDoc
ppr Module
mod SDoc -> SDoc -> SDoc
<> SDoc
dot           -- Not in scope
      NameNotInScope2  -> UnitId -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Module -> UnitId
moduleUnitId Module
mod) SDoc -> SDoc -> SDoc
<> SDoc
colon     -- Module not in
                          SDoc -> SDoc -> SDoc
<> ModuleName -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Module -> ModuleName
moduleName Module
mod) SDoc -> SDoc -> SDoc
<> SDoc
dot          -- scope either
      NameUnqual       -> SDoc
empty                   -- In scope unqualified

pprUnique :: Unique -> SDoc
-- Print a unique unless we are suppressing them
pprUnique :: Unique -> SDoc
pprUnique uniq :: Unique
uniq
  = (DynFlags -> SDoc) -> SDoc
sdocWithDynFlags ((DynFlags -> SDoc) -> SDoc) -> (DynFlags -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \dflags :: DynFlags
dflags ->
    Bool -> SDoc -> SDoc
ppUnless (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressUniques DynFlags
dflags) (SDoc -> SDoc) -> SDoc -> SDoc
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 uniq :: Unique
uniq
  = (DynFlags -> SDoc) -> SDoc
sdocWithDynFlags ((DynFlags -> SDoc) -> SDoc) -> (DynFlags -> SDoc) -> SDoc
forall a b. (a -> b) -> a -> b
$ \dflags :: DynFlags
dflags ->
    Bool -> SDoc -> SDoc
ppUnless (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressUniques DynFlags
dflags) (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$
    Char -> SDoc
char '_' SDoc -> SDoc -> SDoc
<> Unique -> SDoc
pprUniqueAlways Unique
uniq

ppr_occ_name :: OccName -> SDoc
ppr_occ_name :: OccName -> SDoc
ppr_occ_name occ :: 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 occ :: 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
name = String -> SDoc
text "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
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 s :: RealSrcLoc
s -> String -> SDoc
text "at" SDoc -> SDoc -> SDoc
<+> RealSrcLoc -> SDoc
forall a. Outputable a => a -> SDoc
ppr RealSrcLoc
s
       UnhelpfulLoc s :: FastString
s
         | Name -> Bool
isInternalName Name
name Bool -> Bool -> Bool
|| Name -> Bool
isSystemName Name
name
         -> String -> SDoc
text "at" SDoc -> SDoc -> SDoc
<+> FastString -> SDoc
ftext FastString
s
         | Bool
otherwise
         -> String -> SDoc
text "in" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Module -> SDoc
forall a. Outputable a => a -> SDoc
ppr (HasDebugCallStack => Name -> Module
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{..} =
  NameSort -> String
nameSortStableString NameSort
n_sort String -> String -> String
forall a. [a] -> [a] -> [a]
++ "$" String -> String -> String
forall a. [a] -> [a] -> [a]
++ OccName -> String
occNameString OccName
n_occ

nameSortStableString :: NameSort -> String
nameSortStableString :: NameSort -> String
nameSortStableString System = "$_sys"
nameSortStableString Internal = "$_in"
nameSortStableString (External mod :: Module
mod) = Module -> String
moduleStableString Module
mod
nameSortStableString (WiredIn mod :: Module
mod _ _) = 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 n :: a
n = Name -> OccName
nameOccName (a -> Name
forall a. NamedThing a => a -> Name
getName a
n)      -- Default method

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

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

getSrcLoc :: a -> SrcLoc
getSrcLoc           = Name -> SrcLoc
nameSrcLoc           (Name -> SrcLoc) -> (a -> Name) -> a -> SrcLoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Name
forall a. NamedThing a => a -> Name
getName
getSrcSpan :: a -> SrcSpan
getSrcSpan          = Name -> SrcSpan
nameSrcSpan          (Name -> SrcSpan) -> (a -> Name) -> a -> SrcSpan
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Name
forall a. NamedThing a => a -> Name
getName
getOccString :: a -> String
getOccString        = OccName -> String
occNameString        (OccName -> String) -> (a -> OccName) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> OccName
forall a. NamedThing a => a -> OccName
getOccName
getOccFS :: a -> FastString
getOccFS            = OccName -> FastString
occNameFS            (OccName -> FastString) -> (a -> OccName) -> a -> FastString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> OccName
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 :: a -> SDoc
pprInfixName  n :: a
n = Bool -> SDoc -> SDoc
pprInfixVar (OccName -> Bool
isSymOcc (a -> OccName
forall a. NamedThing a => a -> OccName
getOccName a
n)) (a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
n)

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