Name.lhs 20.1 KB
Newer Older
1
%
Simon Marlow's avatar
Simon Marlow committed
2
% (c) The University of Glasgow 2006
3
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 5 6 7
%
\section[Name]{@Name@: to transmit name info from renamer to typechecker}

\begin{code}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
-- |
-- #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
33

Ian Lynagh's avatar
Ian Lynagh committed
34 35 36 37 38 39 40
{-# OPTIONS -fno-warn-tabs #-}
-- The above warning supression flag is a temporary kludge.
-- While working on this module you are encouraged to remove it and
-- detab the module (please do the detabbing in a separate patch). See
--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
-- for details

41 42
module Name (
	-- * The main types
43
	Name,					-- Abstract
44 45 46
	BuiltInSyntax(..),

	-- ** Creating 'Name's
47 48
	mkSystemName, mkSystemNameAt,
        mkInternalName, mkDerivedInternalName, 
49
	mkSystemVarName, mkSysTvName, 
50 51
        mkFCallName,
        mkExternalName, mkWiredInName,
52

53
	-- ** Manipulating and deconstructing 'Name's
54
	nameUnique, setNameUnique,
55
	nameOccName, nameModule, nameModule_maybe,
56
	tidyNameOcc, 
57
	hashName, localiseName,
58
  mkLocalisedOccName,
sof's avatar
sof committed
59

60
	nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,
61

62
	-- ** Predicates on 'Name's
63
	isSystemName, isInternalName, isExternalName,
64 65 66
	isTyVarName, isTyConName, isDataConName, 
	isValName, isVarName,
	isWiredInName, isBuiltInSyntax,
67
	wiredInNameTyThing_maybe, 
68
	nameIsLocalOrFrom, stableNameCmp,
69 70

	-- * Class 'NamedThing' and overloaded friends
71
	NamedThing(..),
72
	getSrcLoc, getSrcSpan, getOccString,
73

74
 	pprInfixName, pprPrefixName, pprModulePrefix,
75 76 77

	-- Re-export the OccName stuff
	module OccName
78
    ) where
79

80 81
#include "Typeable.h"

82 83
import {-# SOURCE #-} TypeRep( TyThing )

Simon Marlow's avatar
Simon Marlow committed
84 85 86 87
import OccName
import Module
import SrcLoc
import Unique
88
import Util
Simon Marlow's avatar
Simon Marlow committed
89
import Maybes
90
import Binary
91
import StaticFlags
92
import FastTypes
Simon Marlow's avatar
Simon Marlow committed
93
import FastString
94
import Outputable
95

96
import Data.Data
97 98
\end{code}

99 100
%************************************************************************
%*									*
101
\subsection[Name-datatype]{The @Name@ datatype, and name construction}
102 103
%*									*
%************************************************************************
104
 
105
\begin{code}
106 107
-- | A unique, unambigious name for something, containing information about where
-- that thing originated.
108 109
data Name = Name {
		n_sort :: NameSort,	-- What sort of name it is
110
		n_occ  :: !OccName,	-- Its occurrence name
111 112
		n_uniq :: FastInt,      -- UNPACK doesn't work, recursive type
--(note later when changing Int# -> FastInt: is that still true about UNPACK?)
113
		n_loc  :: !SrcSpan	-- Definition site
114
	    }
Ian Lynagh's avatar
Ian Lynagh committed
115
    deriving Typeable
116

117 118 119 120
-- 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.

121
data NameSort
122
  = External Module
123
 
124
  | WiredIn Module TyThing BuiltInSyntax
125
	-- A variant of External, for wired-in things
126

127
  | Internal		-- A user-defined Id or TyVar
128 129 130 131
			-- defined in the module being compiled

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

133 134
-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples, 
-- which have special syntactic forms.  They aren't in scope
135
-- as such.
136
data BuiltInSyntax = BuiltInSyntax | UserSyntax
137 138
\end{code}

139 140
Notes about the NameSorts:

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

144
2.  Things with a External name are given C static labels, so they finally
145 146
    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
147
    must be made @External@ first.
148

149 150
3.  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
151 152

4.  A System Name differs in the following ways:
153 154 155 156 157 158 159 160 161
	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.

162 163 164 165 166 167 168 169
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.

170 171 172 173 174
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc
175
nameSrcSpan		:: Name -> SrcSpan
176

177
nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
178
nameOccName name = n_occ  name
179 180
nameSrcLoc  name = srcSpanStart (n_loc name)
nameSrcSpan name = n_loc  name
181 182
\end{code}

183 184 185 186 187 188
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

189
\begin{code}
190 191 192 193
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
194 195
isWiredInName	  :: Name -> Bool

196
isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
197
isWiredInName _                               = False
198

199
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
200
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
twanvl's avatar
twanvl committed
201
wiredInNameTyThing_maybe _                                   = Nothing
202

twanvl's avatar
twanvl committed
203
isBuiltInSyntax :: Name -> Bool
204
isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
twanvl's avatar
twanvl committed
205
isBuiltInSyntax _                                           = False
206

207 208
isExternalName (Name {n_sort = External _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
209
isExternalName _                               = False
210

211
isInternalName name = not (isExternalName name)
212

213
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
twanvl's avatar
twanvl committed
214
nameModule_maybe :: Name -> Maybe Module
215 216
nameModule_maybe (Name { n_sort = External mod})    = Just mod
nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
twanvl's avatar
twanvl committed
217
nameModule_maybe _                                  = Nothing
218

219 220 221 222
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

223 224
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
225

226 227 228
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

229 230 231 232 233 234 235 236 237
isDataConName :: Name -> Bool
isDataConName name = isDataOcc (nameOccName name)

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

isVarName :: Name -> Bool
isVarName = isVarOcc . nameOccName

238
isSystemName (Name {n_sort = System}) = True
twanvl's avatar
twanvl committed
239
isSystemName _                        = False
240 241 242 243 244 245 246 247
\end{code}


%************************************************************************
%*									*
\subsection{Making names}
%*									*
%************************************************************************
248

249
\begin{code}
250 251
-- | 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
252
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
253 254 255 256
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
257 258 259 260 261 262
	-- 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
263 264
        --      * for interface files we tidyCore first, which makes
        --        the OccNames distinct when they need to be
265

266 267 268 269 270
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })
  = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal
         , n_occ = derive_occ occ, n_loc = loc }

271
-- | Create a name which definitely originates in the given module
272
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
273
mkExternalName uniq mod occ loc 
274
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
275
           n_occ = occ, n_loc = loc }
276

277 278
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
279
mkWiredInName mod occ uniq thing built_in
280
  = Name { n_uniq = getKeyFastInt uniq,
281
	   n_sort = WiredIn mod thing built_in,
282
	   n_occ = occ, n_loc = wiredInSrcSpan }
283

284
-- | Create a name brought into being by the compiler
285
mkSystemName :: Unique -> OccName -> Name
286 287 288 289 290
mkSystemName uniq occ = mkSystemNameAt uniq occ noSrcSpan

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

292 293
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
294

295
mkSysTvName :: Unique -> FastString -> Name
296
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)
297

298
-- | Make a name for a foreign call
299
mkFCallName :: Unique -> String -> Name
300 301
mkFCallName uniq str = mkInternalName uniq (mkVarOcc str) noSrcSpan
   -- The encoded string completely describes the ccall
302 303 304
\end{code}

\begin{code}
305 306 307
-- 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.
308
setNameUnique :: Name -> Unique -> Name
309
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
310

311 312 313 314 315 316
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@(Name { n_sort = System }) occ = name { n_occ = occ, n_sort = Internal}
tidyNameOcc name 			    occ = name { n_occ = occ }
317

318
-- | Make the 'Name' into an internal name, regardless of what it was to begin with
319
localiseName :: Name -> Name
320
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
321 322
\end{code}

323 324 325 326 327
\begin{code}
-- |Create a localised variant of a name.  
--
-- If the name is external, encode the original's module name to disambiguate.
--
328 329
mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
mkLocalisedOccName this_mod mk_occ name = mk_occ origin (nameOccName name)
330
  where
331 332 333
    origin 
      | nameIsLocalOrFrom this_mod name = Nothing
      | otherwise                       = Just (moduleNameColons . moduleName . nameModule $ name)
334 335
\end{code}

336 337
%************************************************************************
%*									*
338
\subsection{Hashing and comparison}
339 340 341 342
%*									*
%************************************************************************

\begin{code}
343 344 345 346 347
hashName :: Name -> Int		-- ToDo: should really be Word
hashName name = getKey (nameUnique name) + 1
	-- The +1 avoids keys with lots of zeros in the ls bits, which 
	-- interacts badly with the cheap and cheerful multiplication in
	-- hashExpr
348

349 350
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370

stableNameCmp :: Name -> Name -> Ordering
-- Compare lexicographically
stableNameCmp (Name { n_sort = s1, n_occ = occ1 })
	      (Name { n_sort = s2, n_occ = occ2 })
  = (s1 `sort_cmp` s2) `thenCmp` (occ1 `compare` occ2)
    -- The ordinary compare on OccNames is lexicogrpahic
  where
    -- Later constructors are bigger
    sort_cmp (External m1) (External m2)       = m1 `stableModuleCmp` m2
    sort_cmp (External {}) _                   = LT
    sort_cmp (WiredIn {}) (External {})        = GT
    sort_cmp (WiredIn m1 _ _) (WiredIn m2 _ _) = m1 `stableModuleCmp` m2
    sort_cmp (WiredIn {})     _                = LT
    sort_cmp Internal         (External {})    = GT
    sort_cmp Internal         (WiredIn {})     = GT
    sort_cmp Internal         Internal         = EQ
    sort_cmp Internal         System           = LT
    sort_cmp System           System           = EQ
    sort_cmp System           _                = GT
371
\end{code}
372

373 374 375 376 377 378 379 380
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
381 382
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
383 384

instance Ord Name where
385 386
    a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
    a <	 b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
387 388 389
    a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
    a >	 b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
    compare a b = cmpName a b
390

391
instance Uniquable Name where
392
    getUnique = nameUnique
393

394
instance NamedThing Name where
395
    getName n = n
396 397 398 399 400 401

instance Data Name where
  -- don't traverse?
  toConstr _   = abstractConstr "Name"
  gunfold _ _  = error "gunfold"
  dataTypeOf _ = mkNoRepType "Name"
402 403
\end{code}

404 405 406 407 408 409 410 411
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
412 413 414
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
415

416 417 418
   get bh =
      case getUserData bh of
        UserData { ud_get_name = get_name } -> get_name bh
419
\end{code}
420

421 422 423 424 425
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
426 427 428

\begin{code}
instance Outputable Name where
429 430
    ppr name = pprName name

431 432 433
instance OutputableBndr Name where
    pprBndr _ name = pprName name

twanvl's avatar
twanvl committed
434
pprName :: Name -> SDoc
435
pprName n@(Name {n_sort = sort, n_uniq = u, n_occ = occ})
436
  = getPprStyle $ \ sty ->
437
    case sort of
438 439
      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ n True  builtin
      External mod            -> pprExternal sty uniq mod occ n False UserSyntax
440 441
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
442
  where uniq = mkUniqueGrimily (iBox u)
443

444 445
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Name -> Bool -> BuiltInSyntax -> SDoc
pprExternal sty uniq mod occ name is_wired is_builtin
446
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
447 448 449
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
450
  | debugStyle sty = pp_mod <> ppr_occ_name occ
451 452 453 454
		     <> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
				      pprNameSpaceBrief (occNameSpace occ), 
		 		      pprUnique uniq])
  | BuiltInSyntax <- is_builtin = ppr_occ_name occ  -- Never qualify builtin syntax
455
  | otherwise                   = pprModulePrefix sty mod name <> ppr_occ_name occ
456 457 458
  where
    pp_mod | opt_SuppressModulePrefixes = empty
           | otherwise                  = ppr mod <> dot 
459

twanvl's avatar
twanvl committed
460
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
461
pprInternal sty uniq occ
462
  | codeStyle sty  = pprUnique uniq
463
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
464
				 		       pprUnique uniq])
465
  | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
466 467
			-- For debug dumps, we're not necessarily dumping
			-- tidied code, so we need to print the uniques.
468
  | otherwise      = ppr_occ_name occ	-- User style
469

470
-- Like Internal, except that we only omit the unique in Iface style
twanvl's avatar
twanvl committed
471
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
472
pprSystem sty uniq occ
473
  | codeStyle sty  = pprUnique uniq
474
  | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
475
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
476
  | otherwise	   = ppr_occ_name occ <> ppr_underscore_unique uniq
477 478 479
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
480

481

482
pprModulePrefix :: PprStyle -> Module -> Name -> SDoc
483 484
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in HscTypes
485
pprModulePrefix sty mod name
486 487 488
  | opt_SuppressModulePrefixes = empty
  
  | otherwise
489
  = case qualName sty name of              -- See Outputable.QualifyName:
490 491 492 493 494 495
      NameQual modname -> ppr modname <> dot       -- Name is in scope       
      NameNotInScope1  -> ppr mod <> dot           -- Not in scope
      NameNotInScope2  -> ppr (modulePackageId mod) <> colon     -- Module not in
                          <> ppr (moduleName mod) <> dot         -- scope eithber
      _otherwise       -> empty

496 497 498 499 500 501 502
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 uniq
  | opt_SuppressUniques = empty
  | otherwise		= char '_' <> pprUnique uniq

twanvl's avatar
twanvl committed
503
ppr_occ_name :: OccName -> SDoc
504
ppr_occ_name occ = ftext (occNameFS occ)
505 506
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
507 508 509

-- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
-- cached behind the scenes in the FastString implementation.
twanvl's avatar
twanvl committed
510
ppr_z_occ_name :: OccName -> SDoc
511
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
512

513 514
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531
pprDefinedAt :: Name -> SDoc
pprDefinedAt name = ptext (sLit "Defined") <+> pprNameDefnLoc name

pprNameDefnLoc :: Name -> SDoc
-- Prints "at <loc>" or 
--     or "in <mod>" depending on what info is available
pprNameDefnLoc name 
  = case nameSrcLoc name of
         -- nameSrcLoc rather than nameSrcSpan
	 -- It seems less cluttered to show a location
	 -- rather than a span for the definition point
       RealSrcLoc s -> ptext (sLit "at") <+> ppr s
       UnhelpfulLoc s
         | isInternalName name || isSystemName name
         -> ptext (sLit "at") <+> ftext s
         | otherwise 
         -> ptext (sLit "in") <+> quotes (ppr (nameModule name))
532
\end{code}
533

534 535 536 537 538 539 540
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
541
-- | A class allowing convenient access to the 'Name' of various datatypes
542
class NamedThing a where
543
    getOccName :: a -> OccName
544 545 546
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
547 548 549 550
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
551
getSrcSpan	    :: NamedThing a => a -> SrcSpan
552
getOccString	    :: NamedThing a => a -> String
553

554
getSrcLoc	    = nameSrcLoc	   . getName
555
getSrcSpan	    = nameSrcSpan	   . getName
556
getOccString 	    = occNameString	   . getOccName
557 558 559 560 561 562

pprInfixName, pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc
-- See Outputable.pprPrefixVar, pprInfixVar; 
-- add parens or back-quotes as appropriate
pprInfixName  n = pprInfixVar  (isSymOcc (getOccName n)) (ppr n)
pprPrefixName n = pprPrefixVar (isSymOcc (getOccName n)) (ppr n)
563 564
\end{code}