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