Name.lhs 20 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

34
35
module Name (
	-- * The main types
36
	Name,					-- Abstract
37
38
39
	BuiltInSyntax(..),

	-- ** Creating 'Name's
40
41
	mkSystemName, mkSystemNameAt,
        mkInternalName, mkDerivedInternalName, 
42
	mkSystemVarName, mkSysTvName, 
batterseapower's avatar
batterseapower committed
43
	mkFCallName,
44
        mkTickBoxOpName,
45
	mkExternalName, mkWiredInName,
46

47
	-- ** Manipulating and deconstructing 'Name's
48
	nameUnique, setNameUnique,
49
	nameOccName, nameModule, nameModule_maybe,
50
	tidyNameOcc, 
51
	hashName, localiseName,
52
  mkLocalisedOccName,
sof's avatar
sof committed
53

54
	nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,
55

56
	-- ** Predicates on 'Name's
57
	isSystemName, isInternalName, isExternalName,
58
59
60
	isTyVarName, isTyConName, isDataConName, 
	isValName, isVarName,
	isWiredInName, isBuiltInSyntax,
61
	wiredInNameTyThing_maybe, 
62
	nameIsLocalOrFrom, stableNameCmp,
63
64

	-- * Class 'NamedThing' and overloaded friends
65
	NamedThing(..),
66
	getSrcLoc, getSrcSpan, getOccString,
67

68
 	pprInfixName, pprPrefixName, pprModulePrefix,
69
70
71

	-- Re-export the OccName stuff
	module OccName
72
    ) where
73

74
75
#include "Typeable.h"

76
77
import {-# SOURCE #-} TypeRep( TyThing )

Simon Marlow's avatar
Simon Marlow committed
78
79
80
81
import OccName
import Module
import SrcLoc
import Unique
82
import Util
Simon Marlow's avatar
Simon Marlow committed
83
import Maybes
84
import Binary
85
import StaticFlags
86
import FastTypes
Simon Marlow's avatar
Simon Marlow committed
87
import FastString
88
import Outputable
89

90
import Data.Data
91
92
\end{code}

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

111
112
113
114
-- 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.

115
data NameSort
116
  = External Module
117
 
118
  | WiredIn Module TyThing BuiltInSyntax
119
	-- A variant of External, for wired-in things
120

121
  | Internal		-- A user-defined Id or TyVar
122
123
124
125
			-- defined in the module being compiled

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

127
128
-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples, 
-- which have special syntactic forms.  They aren't in scope
129
-- as such.
130
data BuiltInSyntax = BuiltInSyntax | UserSyntax
131
132
\end{code}

133
134
Notes about the NameSorts:

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

138
2.  Things with a External name are given C static labels, so they finally
139
140
    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
141
    must be made @External@ first.
142

143
144
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
145
146

4.  A System Name differs in the following ways:
147
148
149
150
151
152
153
154
155
	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.

156
157
158
159
160
161
162
163
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.

164
165
166
167
168
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc
169
nameSrcSpan		:: Name -> SrcSpan
170

171
nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
172
nameOccName name = n_occ  name
173
174
nameSrcLoc  name = srcSpanStart (n_loc name)
nameSrcSpan name = n_loc  name
175
176
\end{code}

177
178
179
180
181
182
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

183
\begin{code}
184
185
186
187
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
188
189
isWiredInName	  :: Name -> Bool

190
isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
191
isWiredInName _                               = False
192

193
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
194
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
twanvl's avatar
twanvl committed
195
wiredInNameTyThing_maybe _                                   = Nothing
196

twanvl's avatar
twanvl committed
197
isBuiltInSyntax :: Name -> Bool
198
isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
twanvl's avatar
twanvl committed
199
isBuiltInSyntax _                                           = False
200

201
202
isExternalName (Name {n_sort = External _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
203
isExternalName _                               = False
204

205
isInternalName name = not (isExternalName name)
206

207
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
twanvl's avatar
twanvl committed
208
nameModule_maybe :: Name -> Maybe Module
209
210
nameModule_maybe (Name { n_sort = External mod})    = Just mod
nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
twanvl's avatar
twanvl committed
211
nameModule_maybe _                                  = Nothing
212

213
214
215
216
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

217
218
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
219

220
221
222
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

223
224
225
226
227
228
229
230
231
isDataConName :: Name -> Bool
isDataConName name = isDataOcc (nameOccName name)

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

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

232
isSystemName (Name {n_sort = System}) = True
twanvl's avatar
twanvl committed
233
isSystemName _                        = False
234
235
236
237
238
239
240
241
\end{code}


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

243
\begin{code}
244
245
-- | 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
246
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
247
248
249
250
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
251
252
253
254
255
256
257
258
	-- 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 puts the uniques
	--	  into the print name (see setNameVisibility below)
259

260
261
262
263
264
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 }

265
-- | Create a name which definitely originates in the given module
266
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
267
mkExternalName uniq mod occ loc 
268
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
269
           n_occ = occ, n_loc = loc }
270

271
272
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
273
mkWiredInName mod occ uniq thing built_in
274
  = Name { n_uniq = getKeyFastInt uniq,
275
	   n_sort = WiredIn mod thing built_in,
276
	   n_occ = occ, n_loc = wiredInSrcSpan }
277

278
-- | Create a name brought into being by the compiler
279
mkSystemName :: Unique -> OccName -> Name
280
281
282
283
284
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 }
285

286
287
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
288

289
mkSysTvName :: Unique -> FastString -> Name
290
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)
291

292
-- | Make a name for a foreign call
293
mkFCallName :: Unique -> String -> Name
294
	-- The encoded string completely describes the ccall
295
mkFCallName uniq str =  Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
296
			       n_occ = mkVarOcc str, n_loc = noSrcSpan }
297

298

299
300
mkTickBoxOpName :: Unique -> String -> Name
mkTickBoxOpName uniq str 
301
   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
302
	    n_occ = mkVarOcc str, n_loc = noSrcSpan }
303
304
305
\end{code}

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

312
313
314
315
316
317
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 }
318

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

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

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

\begin{code}
344
345
346
347
348
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
349

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

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
372
\end{code}
373

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

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

instance Ord Name where
386
387
    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 }
388
389
390
    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
391

392
instance Uniquable Name where
393
    getUnique = nameUnique
394

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

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

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

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

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

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

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

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

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

445
446
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Name -> Bool -> BuiltInSyntax -> SDoc
pprExternal sty uniq mod occ name is_wired is_builtin
447
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
448
449
450
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
451
  | debugStyle sty = pp_mod <> ppr_occ_name occ
452
453
454
455
		     <> 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
456
  | otherwise                   = pprModulePrefix sty mod name <> ppr_occ_name occ
457
458
459
  where
    pp_mod | opt_SuppressModulePrefixes = empty
           | otherwise                  = ppr mod <> dot 
460

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

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

482

483
pprModulePrefix :: PprStyle -> Module -> Name -> SDoc
484
485
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in HscTypes
486
pprModulePrefix sty mod name
487
488
489
  | opt_SuppressModulePrefixes = empty
  
  | otherwise
490
  = case qualName sty name of              -- See Outputable.QualifyName:
491
492
493
494
495
496
      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

497
498
499
500
501
502
503
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
504
ppr_occ_name :: OccName -> SDoc
505
ppr_occ_name occ = ftext (occNameFS occ)
506
507
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
508
509
510

-- 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
511
ppr_z_occ_name :: OccName -> SDoc
512
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
513

514
515
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
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))
533
\end{code}
534

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

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

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

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

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

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)
564
565
\end{code}