Module header tidyup, phase 1
[ghc-hetmet.git] / compiler / basicTypes / RdrName.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 \begin{code}
7 module RdrName (
8         RdrName(..),    -- Constructors exported only to BinIface
9
10         -- Construction
11         mkRdrUnqual, mkRdrQual, 
12         mkUnqual, mkVarUnqual, mkQual, mkOrig,
13         nameRdrName, getRdrName, 
14         mkDerivedRdrName, 
15
16         -- Destruction
17         rdrNameOcc, setRdrNameSpace,
18         isRdrDataCon, isRdrTyVar, isRdrTc, isQual, isQual_maybe, isUnqual, 
19         isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName,
20
21         -- Printing;    instance Outputable RdrName
22
23         -- LocalRdrEnv
24         LocalRdrEnv, emptyLocalRdrEnv, extendLocalRdrEnv,
25         lookupLocalRdrEnv, elemLocalRdrEnv,
26
27         -- GlobalRdrEnv
28         GlobalRdrEnv, emptyGlobalRdrEnv, mkGlobalRdrEnv, plusGlobalRdrEnv, 
29         lookupGlobalRdrEnv, extendGlobalRdrEnv,
30         pprGlobalRdrEnv, globalRdrEnvElts,
31         lookupGRE_RdrName, lookupGRE_Name, hideSomeUnquals,
32
33         -- GlobalRdrElt, Provenance, ImportSpec
34         GlobalRdrElt(..), isLocalGRE, unQualOK, 
35         Provenance(..), pprNameProvenance,
36         ImportSpec(..), ImpDeclSpec(..), ImpItemSpec(..), 
37         importSpecLoc, importSpecModule
38   ) where 
39
40 #include "HsVersions.h"
41
42 import OccName
43 import Module
44 import Name
45 import Maybes
46 import SrcLoc
47 import FastString
48 import Outputable
49 import Util
50 \end{code}
51
52 %************************************************************************
53 %*                                                                      *
54 \subsection{The main data type}
55 %*                                                                      *
56 %************************************************************************
57
58 \begin{code}
59 data RdrName 
60   = Unqual OccName
61         -- Used for ordinary, unqualified occurrences 
62
63   | Qual ModuleName OccName
64         -- A qualified name written by the user in 
65         --  *source* code.  The module isn't necessarily 
66         -- the module where the thing is defined; 
67         -- just the one from which it is imported
68
69   | Orig Module OccName
70         -- An original name; the module is the *defining* module.
71         -- This is used when GHC generates code that will be fed
72         -- into the renamer (e.g. from deriving clauses), but where
73         -- we want to say "Use Prelude.map dammit".  
74  
75   | Exact Name
76         -- We know exactly the Name. This is used 
77         --  (a) when the parser parses built-in syntax like "[]" 
78         --      and "(,)", but wants a RdrName from it
79         --  (b) by Template Haskell, when TH has generated a unique name
80 \end{code}
81
82
83 %************************************************************************
84 %*                                                                      *
85 \subsection{Simple functions}
86 %*                                                                      *
87 %************************************************************************
88
89 \begin{code}
90 rdrNameOcc :: RdrName -> OccName
91 rdrNameOcc (Qual _ occ) = occ
92 rdrNameOcc (Unqual occ) = occ
93 rdrNameOcc (Orig _ occ) = occ
94 rdrNameOcc (Exact name) = nameOccName name
95
96 setRdrNameSpace :: RdrName -> NameSpace -> RdrName
97 -- This rather gruesome function is used mainly by the parser
98 -- When parsing         data T a = T | T1 Int
99 -- we parse the data constructors as *types* because of parser ambiguities,
100 -- so then we need to change the *type constr* to a *data constr*
101 --
102 -- The original-name case *can* occur when parsing
103 --              data [] a = [] | a : [a]
104 -- For the orig-name case we return an unqualified name.
105 setRdrNameSpace (Unqual occ) ns = Unqual (setOccNameSpace ns occ)
106 setRdrNameSpace (Qual m occ) ns = Qual m (setOccNameSpace ns occ)
107 setRdrNameSpace (Orig m occ) ns = Orig m (setOccNameSpace ns occ)
108 setRdrNameSpace (Exact n)    ns = Orig (nameModule n)
109                                        (setOccNameSpace ns (nameOccName n))
110 \end{code}
111
112 \begin{code}
113         -- These two are the basic constructors
114 mkRdrUnqual :: OccName -> RdrName
115 mkRdrUnqual occ = Unqual occ
116
117 mkRdrQual :: ModuleName -> OccName -> RdrName
118 mkRdrQual mod occ = Qual mod occ
119
120 mkOrig :: Module -> OccName -> RdrName
121 mkOrig mod occ = Orig mod occ
122
123 ---------------
124 mkDerivedRdrName :: Name -> (OccName -> OccName) -> (RdrName)
125 mkDerivedRdrName parent mk_occ
126   = mkOrig (nameModule parent) (mk_occ (nameOccName parent))
127
128 ---------------
129         -- These two are used when parsing source files
130         -- They do encode the module and occurrence names
131 mkUnqual :: NameSpace -> FastString -> RdrName
132 mkUnqual sp n = Unqual (mkOccNameFS sp n)
133
134 mkVarUnqual :: FastString -> RdrName
135 mkVarUnqual n = Unqual (mkVarOccFS n)
136
137 mkQual :: NameSpace -> (FastString, FastString) -> RdrName
138 mkQual sp (m, n) = Qual (mkModuleNameFS m) (mkOccNameFS sp n)
139
140 getRdrName :: NamedThing thing => thing -> RdrName
141 getRdrName name = nameRdrName (getName name)
142
143 nameRdrName :: Name -> RdrName
144 nameRdrName name = Exact name
145 -- Keep the Name even for Internal names, so that the
146 -- unique is still there for debug printing, particularly
147 -- of Types (which are converted to IfaceTypes before printing)
148
149 nukeExact :: Name -> RdrName
150 nukeExact n 
151   | isExternalName n = Orig (nameModule n) (nameOccName n)
152   | otherwise        = Unqual (nameOccName n)
153 \end{code}
154
155 \begin{code}
156 isRdrDataCon rn = isDataOcc (rdrNameOcc rn)
157 isRdrTyVar   rn = isTvOcc   (rdrNameOcc rn)
158 isRdrTc      rn = isTcOcc   (rdrNameOcc rn)
159
160 isSrcRdrName (Unqual _) = True
161 isSrcRdrName (Qual _ _) = True
162 isSrcRdrName _          = False
163
164 isUnqual (Unqual _) = True
165 isUnqual other      = False
166
167 isQual (Qual _ _) = True
168 isQual _          = False
169
170 isQual_maybe (Qual m n) = Just (m,n)
171 isQual_maybe _          = Nothing
172
173 isOrig (Orig _ _) = True
174 isOrig _          = False
175
176 isOrig_maybe (Orig m n) = Just (m,n)
177 isOrig_maybe _          = Nothing
178
179 isExact (Exact _) = True
180 isExact other   = False
181
182 isExact_maybe (Exact n) = Just n
183 isExact_maybe other     = Nothing
184 \end{code}
185
186
187 %************************************************************************
188 %*                                                                      *
189 \subsection{Instances}
190 %*                                                                      *
191 %************************************************************************
192
193 \begin{code}
194 instance Outputable RdrName where
195     ppr (Exact name)   = ppr name
196     ppr (Unqual occ)   = ppr occ
197     ppr (Qual mod occ) = ppr mod <> dot <> ppr occ
198     ppr (Orig mod occ) = ppr mod <> dot <> ppr occ
199
200 instance OutputableBndr RdrName where
201     pprBndr _ n 
202         | isTvOcc (rdrNameOcc n) = char '@' <+> ppr n
203         | otherwise              = ppr n
204
205 instance Eq RdrName where
206     (Exact n1)    == (Exact n2)    = n1==n2
207         -- Convert exact to orig
208     (Exact n1)    == r2@(Orig _ _) = nukeExact n1 == r2
209     r1@(Orig _ _) == (Exact n2)    = r1 == nukeExact n2
210
211     (Orig m1 o1)  == (Orig m2 o2)  = m1==m2 && o1==o2
212     (Qual m1 o1)  == (Qual m2 o2)  = m1==m2 && o1==o2
213     (Unqual o1)   == (Unqual o2)   = o1==o2
214     r1 == r2 = False
215
216 instance Ord RdrName where
217     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
218     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
219     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
220     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
221
222         -- Exact < Unqual < Qual < Orig
223         -- [Note: Apr 2004] We used to use nukeExact to convert Exact to Orig 
224         --      before comparing so that Prelude.map == the exact Prelude.map, but 
225         --      that meant that we reported duplicates when renaming bindings 
226         --      generated by Template Haskell; e.g 
227         --      do { n1 <- newName "foo"; n2 <- newName "foo"; 
228         --           <decl involving n1,n2> }
229         --      I think we can do without this conversion
230     compare (Exact n1) (Exact n2) = n1 `compare` n2
231     compare (Exact n1) n2         = LT
232
233     compare (Unqual _)   (Exact _)    = GT
234     compare (Unqual o1)  (Unqual  o2) = o1 `compare` o2
235     compare (Unqual _)   _            = LT
236
237     compare (Qual _ _)   (Exact _)    = GT
238     compare (Qual _ _)   (Unqual _)   = GT
239     compare (Qual m1 o1) (Qual m2 o2) = (o1 `compare` o2) `thenCmp` (m1 `compare` m2) 
240     compare (Qual _ _)   (Orig _ _)   = LT
241
242     compare (Orig m1 o1) (Orig m2 o2) = (o1 `compare` o2) `thenCmp` (m1 `compare` m2) 
243     compare (Orig _ _)   _            = GT
244 \end{code}
245
246
247
248 %************************************************************************
249 %*                                                                      *
250                         LocalRdrEnv
251 %*                                                                      *
252 %************************************************************************
253
254 A LocalRdrEnv is used for local bindings (let, where, lambda, case)
255 It is keyed by OccName, because we never use it for qualified names.
256
257 \begin{code}
258 type LocalRdrEnv = OccEnv Name
259
260 emptyLocalRdrEnv = emptyOccEnv
261
262 extendLocalRdrEnv :: LocalRdrEnv -> [Name] -> LocalRdrEnv
263 extendLocalRdrEnv env names
264   = extendOccEnvList env [(nameOccName n, n) | n <- names]
265
266 lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
267 lookupLocalRdrEnv env (Exact name) = Just name
268 lookupLocalRdrEnv env (Unqual occ) = lookupOccEnv env occ
269 lookupLocalRdrEnv env other        = Nothing
270
271 elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
272 elemLocalRdrEnv rdr_name env 
273   | isUnqual rdr_name = rdrNameOcc rdr_name `elemOccEnv` env
274   | otherwise         = False
275 \end{code}
276
277
278 %************************************************************************
279 %*                                                                      *
280                         GlobalRdrEnv
281 %*                                                                      *
282 %************************************************************************
283
284 \begin{code}
285 type GlobalRdrEnv = OccEnv [GlobalRdrElt]
286         -- Keyed by OccName; when looking up a qualified name
287         -- we look up the OccName part, and then check the Provenance
288         -- to see if the appropriate qualification is valid.  This
289         -- saves routinely doubling the size of the env by adding both
290         -- qualified and unqualified names to the domain.
291         --
292         -- The list in the range is reqd because there may be name clashes
293         -- These only get reported on lookup, not on construction
294
295         -- INVARIANT: All the members of the list have distinct 
296         --            gre_name fields; that is, no duplicate Names
297
298 emptyGlobalRdrEnv = emptyOccEnv
299
300 globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]
301 globalRdrEnvElts env = foldOccEnv (++) [] env
302
303 data GlobalRdrElt 
304   = GRE { gre_name   :: Name,
305           gre_prov   :: Provenance      -- Why it's in scope
306     }
307
308 instance Outputable GlobalRdrElt where
309   ppr gre = ppr name <+> parens (pprNameProvenance gre)
310           where
311             name = gre_name gre
312             pp_parent (Just p) = brackets (text "parent:" <+> ppr p)
313             pp_parent Nothing  = empty
314
315 pprGlobalRdrEnv :: GlobalRdrEnv -> SDoc
316 pprGlobalRdrEnv env
317   = vcat (map pp (occEnvElts env))
318   where
319     pp gres = ppr (nameOccName (gre_name (head gres))) <> colon <+> 
320               vcat [ ppr (gre_name gre) <+> pprNameProvenance gre
321                    | gre <- gres]
322 \end{code}
323
324 \begin{code}
325 lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]
326 lookupGlobalRdrEnv env rdr_name = case lookupOccEnv env rdr_name of
327                                         Nothing   -> []
328                                         Just gres -> gres
329
330 extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
331 extendGlobalRdrEnv env gre = extendOccEnv_C add env occ [gre]
332   where
333     occ = nameOccName (gre_name gre)
334     add gres _ = gre:gres
335
336 lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
337 lookupGRE_RdrName rdr_name env
338   = case lookupOccEnv env (rdrNameOcc rdr_name) of
339         Nothing   -> []
340         Just gres -> pickGREs rdr_name gres
341
342 lookupGRE_Name :: GlobalRdrEnv -> Name -> [GlobalRdrElt]
343 lookupGRE_Name env name
344   = [ gre | gre <- lookupGlobalRdrEnv env (nameOccName name),
345             gre_name gre == name ]
346
347
348 pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
349 -- Take a list of GREs which have the right OccName
350 -- Pick those GREs that are suitable for this RdrName
351 -- And for those, keep only only the Provenances that are suitable
352 -- 
353 -- Consider
354 --       module A ( f ) where
355 --       import qualified Foo( f )
356 --       import Baz( f )
357 --       f = undefined
358 -- Let's suppose that Foo.f and Baz.f are the same entity really.
359 -- The export of f is ambiguous because it's in scope from the local def
360 -- and the import.  The lookup of (Unqual f) should return a GRE for
361 -- the locally-defined f, and a GRE for the imported f, with a *single* 
362 -- provenance, namely the one for Baz(f).
363 pickGREs rdr_name gres
364   = mapCatMaybes pick gres
365   where
366     rdr_is_unqual = isUnqual rdr_name
367     rdr_is_qual   = isQual_maybe rdr_name
368
369     pick :: GlobalRdrElt -> Maybe GlobalRdrElt
370     pick gre@(GRE {gre_prov = LocalDef, gre_name = n})  -- Local def
371         | rdr_is_unqual                         = Just gre
372         | Just (mod,_) <- rdr_is_qual, 
373           mod == moduleName (nameModule n)      = Just gre
374         | otherwise                             = Nothing
375     pick gre@(GRE {gre_prov = Imported [is]})   -- Single import (efficiency)
376         | rdr_is_unqual,
377           not (is_qual (is_decl is))            = Just gre
378         | Just (mod,_) <- rdr_is_qual, 
379           mod == is_as (is_decl is)             = Just gre
380         | otherwise                             = Nothing
381     pick gre@(GRE {gre_prov = Imported is})     -- Multiple import
382         | null filtered_is = Nothing
383         | otherwise        = Just (gre {gre_prov = Imported filtered_is})
384         where
385           filtered_is | rdr_is_unqual
386                       = filter (not . is_qual    . is_decl) is
387                       | Just (mod,_) <- rdr_is_qual 
388                       = filter ((== mod) . is_as . is_decl) is
389                       | otherwise
390                       = []
391
392 isLocalGRE :: GlobalRdrElt -> Bool
393 isLocalGRE (GRE {gre_prov = LocalDef}) = True
394 isLocalGRE other                       = False
395
396 unQualOK :: GlobalRdrElt -> Bool
397 -- An unqualifed version of this thing is in scope
398 unQualOK (GRE {gre_prov = LocalDef})    = True
399 unQualOK (GRE {gre_prov = Imported is}) = not (all (is_qual . is_decl) is)
400
401 plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
402 plusGlobalRdrEnv env1 env2 = plusOccEnv_C (foldr insertGRE) env1 env2
403
404 mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
405 mkGlobalRdrEnv gres
406   = foldr add emptyGlobalRdrEnv gres
407   where
408     add gre env = extendOccEnv_C (foldr insertGRE) env 
409                                  (nameOccName (gre_name gre)) 
410                                  [gre]
411
412 insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
413 insertGRE new_g [] = [new_g]
414 insertGRE new_g (old_g : old_gs)
415         | gre_name new_g == gre_name old_g
416         = new_g `plusGRE` old_g : old_gs
417         | otherwise
418         = old_g : insertGRE new_g old_gs
419
420 plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
421 -- Used when the gre_name fields match
422 plusGRE g1 g2
423   = GRE { gre_name = gre_name g1,
424           gre_prov = gre_prov g1 `plusProv` gre_prov g2 }
425
426 hideSomeUnquals :: GlobalRdrEnv -> [OccName] -> GlobalRdrEnv
427 -- Hide any unqualified bindings for the specified OccNames
428 -- This is used in TH, when renaming a declaration bracket
429 --      [d| foo = ... |]
430 -- We want unqualified 'foo' in "..." to mean this foo, not
431 -- the one from the enclosing module.  But the *qualified* name
432 -- from the enclosing moudule must certainly still be avaialable
433 --      Seems like 5 times as much work as it deserves!
434 hideSomeUnquals rdr_env occs
435   = foldr hide rdr_env occs
436   where
437     hide occ env 
438         | Just gres <- lookupOccEnv env occ = extendOccEnv env occ (map qual_gre gres)
439         | otherwise                         = env
440     qual_gre gre@(GRE { gre_name = name, gre_prov = LocalDef })
441         = GRE { gre_name = name, gre_prov = Imported [imp_spec] }
442         where   -- Local defs get transfomed to (fake) imported things
443           mod = moduleName (nameModule name)
444           imp_spec = ImpSpec { is_item = ImpAll, is_decl = decl_spec }
445           decl_spec = ImpDeclSpec { is_mod = mod, is_as = mod, 
446                                     is_qual = True, 
447                                     is_dloc = srcLocSpan (nameSrcLoc name) }
448
449     qual_gre gre@(GRE { gre_prov = Imported specs })
450         = gre { gre_prov = Imported (map qual_spec specs) }
451
452     qual_spec spec@(ImpSpec { is_decl = decl_spec })
453         = spec { is_decl = decl_spec { is_qual = True } }
454 \end{code}
455
456
457 %************************************************************************
458 %*                                                                      *
459                         Provenance
460 %*                                                                      *
461 %************************************************************************
462
463 The "provenance" of something says how it came to be in scope.
464 It's quite elaborate so that we can give accurate unused-name warnings.
465
466 \begin{code}
467 data Provenance
468   = LocalDef            -- Defined locally
469   | Imported            -- Imported
470         [ImportSpec]    -- INVARIANT: non-empty
471
472 data ImportSpec = ImpSpec { is_decl :: ImpDeclSpec,
473                             is_item ::  ImpItemSpec }
474                 deriving( Eq, Ord )
475
476 data ImpDeclSpec        -- Describes a particular import declaration
477                         -- Shared among all the Provenaces for that decl
478   = ImpDeclSpec {
479         is_mod      :: ModuleName, -- 'import Muggle'
480                                 -- Note the Muggle may well not be 
481                                 -- the defining module for this thing!
482                                 -- TODO: either should be Module, or there
483                                 -- should be a Maybe PackageId here too.
484         is_as       :: ModuleName, -- 'as M' (or 'Muggle' if there is no 'as' clause)
485         is_qual     :: Bool,    -- True <=> qualified (only)
486         is_dloc     :: SrcSpan  -- Location of import declaration
487     }
488
489 data ImpItemSpec  -- Describes import info a particular Name
490   = ImpAll              -- The import had no import list, 
491                         -- or  had a hiding list
492
493   | ImpSome {           -- The import had an import list
494         is_explicit :: Bool,
495         is_iloc     :: SrcSpan  -- Location of the import item
496     }
497         -- The is_explicit field is True iff the thing was named 
498         -- *explicitly* in the import specs rather 
499         -- than being imported as part of a "..." group 
500         -- e.g.         import C( T(..) )
501         -- Here the constructors of T are not named explicitly; 
502         -- only T is named explicitly.
503
504 importSpecLoc :: ImportSpec -> SrcSpan
505 importSpecLoc (ImpSpec decl ImpAll) = is_dloc decl
506 importSpecLoc (ImpSpec _    item)   = is_iloc item
507
508 importSpecModule :: ImportSpec -> ModuleName
509 importSpecModule is = is_mod (is_decl is)
510
511 -- Note [Comparing provenance]
512 -- Comparison of provenance is just used for grouping 
513 -- error messages (in RnEnv.warnUnusedBinds)
514 instance Eq Provenance where
515   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
516
517 instance Eq ImpDeclSpec where
518   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
519
520 instance Eq ImpItemSpec where
521   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
522
523 instance Ord Provenance where
524    compare LocalDef      LocalDef        = EQ
525    compare LocalDef      (Imported _)    = LT
526    compare (Imported _ ) LocalDef        = GT
527    compare (Imported is1) (Imported is2) = compare (head is1) 
528         {- See Note [Comparing provenance] -}      (head is2)
529
530 instance Ord ImpDeclSpec where
531    compare is1 is2 = (is_mod is1 `compare` is_mod is2) `thenCmp` 
532                      (is_dloc is1 `compare` is_dloc is2)
533
534 instance Ord ImpItemSpec where
535    compare is1 is2 = is_iloc is1 `compare` is_iloc is2
536 \end{code}
537
538 \begin{code}
539 plusProv :: Provenance -> Provenance -> Provenance
540 -- Choose LocalDef over Imported
541 -- There is an obscure bug lurking here; in the presence
542 -- of recursive modules, something can be imported *and* locally
543 -- defined, and one might refer to it with a qualified name from
544 -- the import -- but I'm going to ignore that because it makes
545 -- the isLocalGRE predicate so much nicer this way
546 plusProv LocalDef        LocalDef        = panic "plusProv"
547 plusProv LocalDef        p2              = LocalDef
548 plusProv p1              LocalDef        = LocalDef
549 plusProv (Imported is1)  (Imported is2)  = Imported (is1++is2)
550
551 pprNameProvenance :: GlobalRdrElt -> SDoc
552 -- Print out the place where the name was imported
553 pprNameProvenance (GRE {gre_name = name, gre_prov = LocalDef})
554   = ptext SLIT("defined at") <+> ppr (nameSrcLoc name)
555 pprNameProvenance (GRE {gre_name = name, gre_prov = Imported whys})
556   = case whys of
557         (why:whys) -> sep [ppr why, nest 2 (ppr_defn (nameSrcLoc name))]
558         [] -> panic "pprNameProvenance"
559
560 -- If we know the exact definition point (which we may do with GHCi)
561 -- then show that too.  But not if it's just "imported from X".
562 ppr_defn loc | isGoodSrcLoc loc = parens (ptext SLIT("defined at") <+> ppr loc)
563              | otherwise        = empty
564
565 instance Outputable ImportSpec where
566    ppr imp_spec
567      = ptext SLIT("imported from") <+> ppr (importSpecModule imp_spec) 
568         <+> if isGoodSrcSpan loc then ptext SLIT("at") <+> ppr loc
569                                  else empty
570      where
571        loc = importSpecLoc imp_spec
572 \end{code}