Typos in comments
[ghc.git] / compiler / basicTypes / Name.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 \section[Name]{@Name@: to transmit name info from renamer to typechecker}
6
7 \begin{code}
8 -- |
9 -- #name_types#
10 -- GHC uses several kinds of name internally:
11 --
12 -- * 'OccName.OccName': see "OccName#name_types"
13 --
14 -- * 'RdrName.RdrName': see "RdrName#name_types"
15 --
16 -- *  'Name.Name' is the type of names that have had their scoping and binding resolved. They
17 --   have an 'OccName.OccName' but also a 'Unique.Unique' that disambiguates Names that have
18 --   the same 'OccName.OccName' and indeed is used for all 'Name.Name' comparison. Names
19 --   also contain information about where they originated from, see "Name#name_sorts"
20 --
21 -- * 'Id.Id': see "Id#name_types"
22 --
23 -- * 'Var.Var': see "Var#name_types"
24 --
25 -- #name_sorts#
26 -- Names are one of:
27 --
28 --  * External, if they name things declared in other modules. Some external
29 --    Names are wired in, i.e. they name primitives defined in the compiler itself
30 --
31 --  * Internal, if they name things in the module being compiled. Some internal
32 --    Names are system names, if they are names manufactured by the compiler
33
34 module Name (
35         -- * The main types
36         Name,                                   -- Abstract
37         BuiltInSyntax(..),
38
39         -- ** Creating 'Name's
40         mkSystemName, mkSystemNameAt,
41         mkInternalName, mkClonedInternalName, mkDerivedInternalName,
42         mkSystemVarName, mkSysTvName,
43         mkFCallName,
44         mkExternalName, mkWiredInName,
45
46         -- ** Manipulating and deconstructing 'Name's
47         nameUnique, setNameUnique,
48         nameOccName, nameModule, nameModule_maybe,
49         tidyNameOcc,
50         hashName, localiseName,
51         mkLocalisedOccName,
52
53         nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,
54
55         -- ** Predicates on 'Name's
56         isSystemName, isInternalName, isExternalName,
57         isTyVarName, isTyConName, isDataConName,
58         isValName, isVarName,
59         isWiredInName, isBuiltInSyntax,
60         wiredInNameTyThing_maybe,
61         nameIsLocalOrFrom, stableNameCmp,
62
63         -- * Class 'NamedThing' and overloaded friends
64         NamedThing(..),
65         getSrcLoc, getSrcSpan, getOccString,
66
67         pprInfixName, pprPrefixName, pprModulePrefix,
68
69         -- Re-export the OccName stuff
70         module OccName
71     ) where
72
73 #include "Typeable.h"
74
75 import {-# SOURCE #-} TypeRep( TyThing )
76 import {-# SOURCE #-} PrelNames( liftedTypeKindTyConKey )
77
78 import OccName
79 import Module
80 import SrcLoc
81 import Unique
82 import Util
83 import Maybes
84 import Binary
85 import DynFlags
86 import FastTypes
87 import FastString
88 import Outputable
89
90 import Data.Data
91 \end{code}
92
93 %************************************************************************
94 %*                                                                      *
95 \subsection[Name-datatype]{The @Name@ datatype, and name construction}
96 %*                                                                      *
97 %************************************************************************
98
99 \begin{code}
100 -- | A unique, unambigious name for something, containing information about where
101 -- that thing originated.
102 data Name = Name {
103                 n_sort :: NameSort,     -- What sort of name it is
104                 n_occ  :: !OccName,     -- Its occurrence name
105                 n_uniq :: FastInt,      -- UNPACK doesn't work, recursive type
106 --(note later when changing Int# -> FastInt: is that still true about UNPACK?)
107                 n_loc  :: !SrcSpan      -- Definition site
108             }
109     deriving Typeable
110
111 -- NOTE: we make the n_loc field strict to eliminate some potential
112 -- (and real!) space leaks, due to the fact that we don't look at
113 -- the SrcLoc in a Name all that often.
114
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                         -- defined in the module being compiled
123
124   | System              -- A system-defined Id or TyVar.  Typically the
125                         -- OccName is very uninformative (like 's')
126
127 -- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples,
128 -- which have special syntactic forms.  They aren't in scope
129 -- as such.
130 data BuiltInSyntax = BuiltInSyntax | UserSyntax
131 \end{code}
132
133 Notes about the NameSorts:
134
135 1.  Initially, top-level Ids (including locally-defined ones) get External names,
136     and all other local Ids get Internal names
137
138 2.  In any invocation of GHC, an External Name for "M.x" has one and only one
139     unique.  This unique association is ensured via the Name Cache; 
140     see Note [The Name Cache] in IfaceEnv.
141
142 3.  Things with a External name are given C static labels, so they finally
143     appear in the .o file's symbol table.  They appear in the symbol table
144     in the form M.n.  If originally-local things have this property they
145     must be made @External@ first.
146
147 4.  In the tidy-core phase, a External that is not visible to an importer
148     is changed to Internal, and a Internal that is visible is changed to External
149
150 5.  A System Name differs in the following ways:
151         a) has unique attached when printing dumps
152         b) unifier eliminates sys tyvars in favour of user provs where possible
153
154     Before anything gets printed in interface files or output code, it's
155     fed through a 'tidy' processor, which zaps the OccNames to have
156     unique names; and converts all sys-locals to user locals
157     If any desugarer sys-locals have survived that far, they get changed to
158     "ds1", "ds2", etc.
159
160 Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])
161
162 Wired-in thing  => The thing (Id, TyCon) is fully known to the compiler,
163                    not read from an interface file.
164                    E.g. Bool, True, Int, Float, and many others
165
166 All built-in syntax is for wired-in things.
167
168 \begin{code}
169 instance HasOccName Name where
170   occName = nameOccName
171
172 nameUnique              :: Name -> Unique
173 nameOccName             :: Name -> OccName
174 nameModule              :: Name -> Module
175 nameSrcLoc              :: Name -> SrcLoc
176 nameSrcSpan             :: Name -> SrcSpan
177
178 nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
179 nameOccName name = n_occ  name
180 nameSrcLoc  name = srcSpanStart (n_loc name)
181 nameSrcSpan name = n_loc  name
182 \end{code}
183
184 %************************************************************************
185 %*                                                                      *
186 \subsection{Predicates on names}
187 %*                                                                      *
188 %************************************************************************
189
190 \begin{code}
191 nameIsLocalOrFrom :: Module -> Name -> Bool
192 isInternalName    :: Name -> Bool
193 isExternalName    :: Name -> Bool
194 isSystemName      :: Name -> Bool
195 isWiredInName     :: Name -> Bool
196
197 isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
198 isWiredInName _                               = False
199
200 wiredInNameTyThing_maybe :: Name -> Maybe TyThing
201 wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
202 wiredInNameTyThing_maybe _                                   = Nothing
203
204 isBuiltInSyntax :: Name -> Bool
205 isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
206 isBuiltInSyntax _                                           = False
207
208 isExternalName (Name {n_sort = External _})    = True
209 isExternalName (Name {n_sort = WiredIn _ _ _}) = True
210 isExternalName _                               = False
211
212 isInternalName name = not (isExternalName name)
213
214 nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
215 nameModule_maybe :: Name -> Maybe Module
216 nameModule_maybe (Name { n_sort = External mod})    = Just mod
217 nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
218 nameModule_maybe _                                  = Nothing
219
220 nameIsLocalOrFrom from name
221   | isExternalName name = from == nameModule name
222   | otherwise           = True
223
224 isTyVarName :: Name -> Bool
225 isTyVarName name = isTvOcc (nameOccName name)
226
227 isTyConName :: Name -> Bool
228 isTyConName name = isTcOcc (nameOccName name)
229
230 isDataConName :: Name -> Bool
231 isDataConName name = isDataOcc (nameOccName name)
232
233 isValName :: Name -> Bool
234 isValName name = isValOcc (nameOccName name)
235
236 isVarName :: Name -> Bool
237 isVarName = isVarOcc . nameOccName
238
239 isSystemName (Name {n_sort = System}) = True
240 isSystemName _                        = False
241 \end{code}
242
243
244 %************************************************************************
245 %*                                                                      *
246 \subsection{Making names}
247 %*                                                                      *
248 %************************************************************************
249
250 \begin{code}
251 -- | Create a name which is (for now at least) local to the current module and hence
252 -- does not need a 'Module' to disambiguate it from other 'Name's
253 mkInternalName :: Unique -> OccName -> SrcSpan -> Name
254 mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
255                                    , n_sort = Internal
256                                    , n_occ = occ
257                                    , n_loc = loc }
258         -- NB: You might worry that after lots of huffing and
259         -- puffing we might end up with two local names with distinct
260         -- uniques, but the same OccName.  Indeed we can, but that's ok
261         --      * the insides of the compiler don't care: they use the Unique
262         --      * when printing for -ddump-xxx you can switch on -dppr-debug to get the
263         --        uniques if you get confused
264         --      * for interface files we tidyCore first, which makes
265         --        the OccNames distinct when they need to be
266
267 mkClonedInternalName :: Unique -> Name -> Name
268 mkClonedInternalName uniq (Name { n_occ = occ, n_loc = loc })
269   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal
270          , n_occ = occ, n_loc = loc }
271
272 mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
273 mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })
274   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal
275          , n_occ = derive_occ occ, n_loc = loc }
276
277 -- | Create a name which definitely originates in the given module
278 mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
279 -- WATCH OUT! External Names should be in the Name Cache
280 -- (see Note [The Name Cache] in IfaceEnv), so don't just call mkExternalName
281 -- with some fresh unique without populating the Name Cache
282 mkExternalName uniq mod occ loc
283   = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
284            n_occ = occ, n_loc = loc }
285
286 -- | Create a name which is actually defined by the compiler itself
287 mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
288 mkWiredInName mod occ uniq thing built_in
289   = Name { n_uniq = getKeyFastInt uniq,
290            n_sort = WiredIn mod thing built_in,
291            n_occ = occ, n_loc = wiredInSrcSpan }
292
293 -- | Create a name brought into being by the compiler
294 mkSystemName :: Unique -> OccName -> Name
295 mkSystemName uniq occ = mkSystemNameAt uniq occ noSrcSpan
296
297 mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
298 mkSystemNameAt uniq occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = System
299                                    , n_occ = occ, n_loc = loc }
300
301 mkSystemVarName :: Unique -> FastString -> Name
302 mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
303
304 mkSysTvName :: Unique -> FastString -> Name
305 mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)
306
307 -- | Make a name for a foreign call
308 mkFCallName :: Unique -> String -> Name
309 mkFCallName uniq str = mkInternalName uniq (mkVarOcc str) noSrcSpan
310    -- The encoded string completely describes the ccall
311 \end{code}
312
313 \begin{code}
314 -- When we renumber/rename things, we need to be
315 -- able to change a Name's Unique to match the cached
316 -- one in the thing it's the name of.  If you know what I mean.
317 setNameUnique :: Name -> Unique -> Name
318 setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
319
320 tidyNameOcc :: Name -> OccName -> Name
321 -- We set the OccName of a Name when tidying
322 -- In doing so, we change System --> Internal, so that when we print
323 -- it we don't get the unique by default.  It's tidy now!
324 tidyNameOcc name@(Name { n_sort = System }) occ = name { n_occ = occ, n_sort = Internal}
325 tidyNameOcc name                            occ = name { n_occ = occ }
326
327 -- | Make the 'Name' into an internal name, regardless of what it was to begin with
328 localiseName :: Name -> Name
329 localiseName n = n { n_sort = Internal }
330 \end{code}
331
332 \begin{code}
333 -- |Create a localised variant of a name.
334 --
335 -- If the name is external, encode the original's module name to disambiguate.
336 --
337 mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
338 mkLocalisedOccName this_mod mk_occ name = mk_occ origin (nameOccName name)
339   where
340     origin
341       | nameIsLocalOrFrom this_mod name = Nothing
342       | otherwise                       = Just (moduleNameColons . moduleName . nameModule $ name)
343 \end{code}
344
345 %************************************************************************
346 %*                                                                      *
347 \subsection{Hashing and comparison}
348 %*                                                                      *
349 %************************************************************************
350
351 \begin{code}
352 hashName :: Name -> Int         -- ToDo: should really be Word
353 hashName name = getKey (nameUnique name) + 1
354         -- The +1 avoids keys with lots of zeros in the ls bits, which
355         -- interacts badly with the cheap and cheerful multiplication in
356         -- hashExpr
357
358 cmpName :: Name -> Name -> Ordering
359 cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
360
361 stableNameCmp :: Name -> Name -> Ordering
362 -- Compare lexicographically
363 stableNameCmp (Name { n_sort = s1, n_occ = occ1 })
364               (Name { n_sort = s2, n_occ = occ2 })
365   = (s1 `sort_cmp` s2) `thenCmp` (occ1 `compare` occ2)
366     -- The ordinary compare on OccNames is lexicogrpahic
367   where
368     -- Later constructors are bigger
369     sort_cmp (External m1) (External m2)       = m1 `stableModuleCmp` m2
370     sort_cmp (External {}) _                   = LT
371     sort_cmp (WiredIn {}) (External {})        = GT
372     sort_cmp (WiredIn m1 _ _) (WiredIn m2 _ _) = m1 `stableModuleCmp` m2
373     sort_cmp (WiredIn {})     _                = LT
374     sort_cmp Internal         (External {})    = GT
375     sort_cmp Internal         (WiredIn {})     = GT
376     sort_cmp Internal         Internal         = EQ
377     sort_cmp Internal         System           = LT
378     sort_cmp System           System           = EQ
379     sort_cmp System           _                = GT
380 \end{code}
381
382 %************************************************************************
383 %*                                                                      *
384 \subsection[Name-instances]{Instance declarations}
385 %*                                                                      *
386 %************************************************************************
387
388 \begin{code}
389 instance Eq Name where
390     a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
391     a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
392
393 instance Ord Name where
394     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
395     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
396     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
397     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
398     compare a b = cmpName a b
399
400 instance Uniquable Name where
401     getUnique = nameUnique
402
403 instance NamedThing Name where
404     getName n = n
405
406 instance Data Name where
407   -- don't traverse?
408   toConstr _   = abstractConstr "Name"
409   gunfold _ _  = error "gunfold"
410   dataTypeOf _ = mkNoRepType "Name"
411 \end{code}
412
413 %************************************************************************
414 %*                                                                      *
415 \subsection{Binary}
416 %*                                                                      *
417 %************************************************************************
418
419 \begin{code}
420 instance Binary Name where
421    put_ bh name =
422       case getUserData bh of
423         UserData{ ud_put_name = put_name } -> put_name bh name
424
425    get bh =
426       case getUserData bh of
427         UserData { ud_get_name = get_name } -> get_name bh
428 \end{code}
429
430 %************************************************************************
431 %*                                                                      *
432 \subsection{Pretty printing}
433 %*                                                                      *
434 %************************************************************************
435
436 \begin{code}
437 instance Outputable Name where
438     ppr name = pprName name
439
440 instance OutputableBndr Name where
441     pprBndr _ name = pprName name
442     pprInfixOcc  = pprInfixName
443     pprPrefixOcc = pprPrefixName
444
445
446 pprName :: Name -> SDoc
447 pprName n@(Name {n_sort = sort, n_uniq = u, n_occ = occ})
448   = getPprStyle $ \ sty ->
449     case sort of
450       WiredIn mod _ builtin   -> pprExternal sty uniq mod occ n True  builtin
451       External mod            -> pprExternal sty uniq mod occ n False UserSyntax
452       System                  -> pprSystem sty uniq occ
453       Internal                -> pprInternal sty uniq occ
454   where uniq = mkUniqueGrimily (iBox u)
455
456 pprExternal :: PprStyle -> Unique -> Module -> OccName -> Name -> Bool -> BuiltInSyntax -> SDoc
457 pprExternal sty uniq mod occ name is_wired is_builtin
458   | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
459         -- In code style, always qualify
460         -- ToDo: maybe we could print all wired-in things unqualified
461         --       in code style, to reduce symbol table bloat?
462   | debugStyle sty = pp_mod <> ppr_occ_name occ
463                      <> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
464                                       pprNameSpaceBrief (occNameSpace occ),
465                                       pprUnique uniq])
466   | BuiltInSyntax <- is_builtin = ppr_occ_name occ  -- Never qualify builtin syntax
467   | otherwise                   = pprModulePrefix sty mod name <> ppr_occ_name occ
468   where
469     pp_mod = sdocWithDynFlags $ \dflags ->
470              if gopt Opt_SuppressModulePrefixes dflags
471              then empty
472              else ppr mod <> dot
473
474 pprInternal :: PprStyle -> Unique -> OccName -> SDoc
475 pprInternal sty uniq occ
476   | codeStyle sty  = pprUnique uniq
477   | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ),
478                                                        pprUnique uniq])
479   | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
480                         -- For debug dumps, we're not necessarily dumping
481                         -- tidied code, so we need to print the uniques.
482   | otherwise      = ppr_occ_name occ   -- User style
483
484 -- Like Internal, except that we only omit the unique in Iface style
485 pprSystem :: PprStyle -> Unique -> OccName -> SDoc
486 pprSystem sty uniq occ
487   | codeStyle sty  = pprUnique uniq
488   | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
489                      <> braces (pprNameSpaceBrief (occNameSpace occ))
490   | otherwise      = ppr_occ_name occ <> ppr_underscore_unique uniq
491                                 -- If the tidy phase hasn't run, the OccName
492                                 -- is unlikely to be informative (like 's'),
493                                 -- so print the unique
494
495
496 pprModulePrefix :: PprStyle -> Module -> Name -> SDoc
497 -- Print the "M." part of a name, based on whether it's in scope or not
498 -- See Note [Printing original names] in HscTypes
499 pprModulePrefix sty mod name = sdocWithDynFlags $ \dflags ->
500   if gopt Opt_SuppressModulePrefixes dflags
501   then empty
502   else
503     case qualName sty name of              -- See Outputable.QualifyName:
504       NameQual modname -> ppr modname <> dot       -- Name is in scope
505       NameNotInScope1  -> ppr mod <> dot           -- Not in scope
506       NameNotInScope2  -> ppr (modulePackageId mod) <> colon     -- Module not in
507                           <> ppr (moduleName mod) <> dot         -- scope eithber
508       _otherwise       -> empty
509
510 ppr_underscore_unique :: Unique -> SDoc
511 -- Print an underscore separating the name from its unique
512 -- But suppress it if we aren't printing the uniques anyway
513 ppr_underscore_unique uniq
514   = sdocWithDynFlags $ \dflags ->
515     if gopt Opt_SuppressUniques dflags
516     then empty
517     else char '_' <> pprUnique uniq
518
519 ppr_occ_name :: OccName -> SDoc
520 ppr_occ_name occ = ftext (occNameFS occ)
521         -- Don't use pprOccName; instead, just print the string of the OccName;
522         -- we print the namespace in the debug stuff above
523
524 -- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
525 -- cached behind the scenes in the FastString implementation.
526 ppr_z_occ_name :: OccName -> SDoc
527 ppr_z_occ_name occ = ztext (zEncodeFS (occNameFS occ))
528
529 -- Prints (if mod information is available) "Defined at <loc>" or
530 --  "Defined in <mod>" information for a Name.
531 pprDefinedAt :: Name -> SDoc
532 pprDefinedAt name = ptext (sLit "Defined") <+> pprNameDefnLoc name
533
534 pprNameDefnLoc :: Name -> SDoc
535 -- Prints "at <loc>" or
536 --     or "in <mod>" depending on what info is available
537 pprNameDefnLoc name
538   = case nameSrcLoc name of
539          -- nameSrcLoc rather than nameSrcSpan
540          -- It seems less cluttered to show a location
541          -- rather than a span for the definition point
542        RealSrcLoc s -> ptext (sLit "at") <+> ppr s
543        UnhelpfulLoc s
544          | isInternalName name || isSystemName name
545          -> ptext (sLit "at") <+> ftext s
546          | otherwise
547          -> ptext (sLit "in") <+> quotes (ppr (nameModule name))
548 \end{code}
549
550 %************************************************************************
551 %*                                                                      *
552 \subsection{Overloaded functions related to Names}
553 %*                                                                      *
554 %************************************************************************
555
556 \begin{code}
557 -- | A class allowing convenient access to the 'Name' of various datatypes
558 class NamedThing a where
559     getOccName :: a -> OccName
560     getName    :: a -> Name
561
562     getOccName n = nameOccName (getName n)      -- Default method
563 \end{code}
564
565 \begin{code}
566 getSrcLoc           :: NamedThing a => a -> SrcLoc
567 getSrcSpan          :: NamedThing a => a -> SrcSpan
568 getOccString        :: NamedThing a => a -> String
569
570 getSrcLoc           = nameSrcLoc           . getName
571 getSrcSpan          = nameSrcSpan          . getName
572 getOccString        = occNameString        . getOccName
573
574 pprInfixName, pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc
575 -- See Outputable.pprPrefixVar, pprInfixVar;
576 -- add parens or back-quotes as appropriate
577 pprInfixName  n = pprInfixVar (isSymOcc (getOccName n)) (ppr n)
578
579 pprPrefixName thing 
580  |  name `hasKey` liftedTypeKindTyConKey 
581  = ppr name   -- See Note [Special treatment for kind *]
582  | otherwise
583  = pprPrefixVar (isSymOcc (nameOccName name)) (ppr name)
584  where
585    name = getName thing
586 \end{code}
587
588 Note [Special treatment for kind *]
589 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
590 Do not put parens around the kind '*'.  Even though it looks like
591 an operator, it is really a special case.
592
593 This pprPrefixName stuff is really only used when printing HsSyn,
594 which has to be polymorphic in the name type, and hence has to go via
595 the overloaded function pprPrefixOcc.  It's easier where we know the
596 type being pretty printed; eg the pretty-printing code in TypeRep.
597
598 See Trac #7645, which led to this.
599