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

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

Simon Marlow's avatar
Simon Marlow committed
90
import Data.Array
91
import Data.Data
92
import Data.Word        ( Word32 )
93 94
\end{code}

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

113 114 115 116
-- 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.

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

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

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

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

135 136
Notes about the NameSorts:

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

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

145 146
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
147 148

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

158 159 160 161 162 163 164 165
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.

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

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

179 180 181 182 183 184
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

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

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

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

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

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

207
isInternalName name = not (isExternalName name)
208

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

215 216 217 218
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

219 220
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
221

222 223 224
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

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

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

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

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


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

245
\begin{code}
246 247
-- | 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
248
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
249 250 251 252
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
253 254 255 256 257 258 259 260
	-- 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)
261

262 263 264 265 266
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 }

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

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

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

288 289
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
290

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

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

300

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

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

314 315 316 317 318 319
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 }
320

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

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

339 340
%************************************************************************
%*									*
341
\subsection{Hashing and comparison}
342 343 344 345
%*									*
%************************************************************************

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

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

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
374
\end{code}
375

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

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

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

394
instance Uniquable Name where
395
    getUnique = nameUnique
396

397
instance NamedThing Name where
398
    getName n = n
399 400 401 402 403 404

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

407 408 409 410 411 412 413 414
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
415 416 417
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
418 419 420

   get bh = do
        i <- get bh
421
        return $! (ud_symtab (getUserData bh) ! fromIntegral (i::Word32))
422
\end{code}
423

424 425 426 427 428
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
429 430 431

\begin{code}
instance Outputable Name where
432 433
    ppr name = pprName name

434 435 436
instance OutputableBndr Name where
    pprBndr _ name = pprName name

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

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

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

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

484

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

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

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

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

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

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

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

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

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

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)
566 567
\end{code}