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
   8 -- |
   9 -- #name_types#
  10 -- GHC uses several kinds of name internally:
  11 --
  12 -- * 'OccName.OccName': see "OccName#name_types"
  13 --
  14 -- * 'RdrName.RdrName' is the type of names that come directly from the parser. They
  15 --   have not yet had their scoping and binding resolved by the renamer and can be
  16 --   thought of to a first approximation as an 'OccName.OccName' with an optional module
  17 --   qualifier
  18 --
  19 -- * 'Name.Name': see "Name#name_types"
  20 --
  21 -- * 'Id.Id': see "Id#name_types"
  22 --
  23 -- * 'Var.Var': see "Var#name_types"
  24 module RdrName (
  25         -- * The main type
  26         RdrName(..),    -- Constructors exported only to BinIface
  27
  28         -- ** Construction
  29         mkRdrUnqual, mkRdrQual,
  30         mkUnqual, mkVarUnqual, mkQual, mkOrig,
  31         nameRdrName, getRdrName,
  32         mkDerivedRdrName,
  33
  34         -- ** Destruction
  35         rdrNameOcc, rdrNameSpace, setRdrNameSpace,
  36         isRdrDataCon, isRdrTyVar, isRdrTc, isQual, isQual_maybe, isUnqual,
  37         isOrig, isOrig_maybe, isExact, isExact_maybe, isSrcRdrName,
  38
  39         -- ** Printing
  40         showRdrName,
  41
  42         -- * Local mapping of 'RdrName' to 'Name.Name'
  43         LocalRdrEnv, emptyLocalRdrEnv, extendLocalRdrEnv, extendLocalRdrEnvList,
  44         lookupLocalRdrEnv, lookupLocalRdrOcc, elemLocalRdrEnv,
  45
  46         -- * Global mapping of 'RdrName' to 'GlobalRdrElt's
  47         GlobalRdrEnv, emptyGlobalRdrEnv, mkGlobalRdrEnv, plusGlobalRdrEnv,
  48         lookupGlobalRdrEnv, extendGlobalRdrEnv,
  49         pprGlobalRdrEnv, globalRdrEnvElts,
  50         lookupGRE_RdrName, lookupGRE_Name, getGRE_NameQualifier_maybes,
  51         hideSomeUnquals, findLocalDupsRdrEnv, pickGREs,
  52
  53         -- ** Global 'RdrName' mapping elements: 'GlobalRdrElt', 'Provenance', 'ImportSpec'
  54         GlobalRdrElt(..), isLocalGRE, unQualOK, qualSpecOK, unQualSpecOK,
  55         Provenance(..), pprNameProvenance,
  56         Parent(..),
  57         ImportSpec(..), ImpDeclSpec(..), ImpItemSpec(..),
  58         importSpecLoc, importSpecModule, isExplicitItem
  59   ) where
  60
  61 #include "HsVersions.h"
  62
  63 import Module
  64 import Name
  65 import Maybes
  66 import SrcLoc
  67 import FastString
  68 import Outputable
  69 import Util
  70 \end{code}
  71
  72 %************************************************************************
  73 %*                                                                      *
  74 \subsection{The main data type}
  75 %*                                                                      *
  76 %************************************************************************
  77
  78 \begin{code}
  79 -- | Do not use the data constructors of RdrName directly: prefer the family
  80 -- of functions that creates them, such as 'mkRdrUnqual'
  81 data RdrName
  82   = Unqual OccName
  83         -- ^ Used for ordinary, unqualified occurrences, e.g. @x@, @y@ or @Foo@.
  84         -- Create such a 'RdrName' with 'mkRdrUnqual'
  85
  86   | Qual ModuleName OccName
  87         -- ^ A qualified name written by the user in
  88         -- /source/ code.  The module isn't necessarily
  89         -- the module where the thing is defined;
  90         -- just the one from which it is imported.
  91         -- Examples are @Bar.x@, @Bar.y@ or @Bar.Foo@.
  92         -- Create such a 'RdrName' with 'mkRdrQual'
  93
  94   | Orig Module OccName
  95         -- ^ An original name; the module is the /defining/ module.
  96         -- This is used when GHC generates code that will be fed
  97         -- into the renamer (e.g. from deriving clauses), but where
  98         -- we want to say \"Use Prelude.map dammit\". One of these
  99         -- can be created with 'mkOrig'
 100
 101   | Exact Name
 102         -- ^ We know exactly the 'Name'. This is used:
 103         --
 104         --  (1) When the parser parses built-in syntax like @[]@
 105         --      and @(,)@, but wants a 'RdrName' from it
 106         --
 107         --  (2) By Template Haskell, when TH has generated a unique name
 108         --
 109         -- Such a 'RdrName' can be created by using 'getRdrName' on a 'Name'
 110 \end{code}
 111
 112
 113 %************************************************************************
 114 %*                                                                      *
 115 \subsection{Simple functions}
 116 %*                                                                      *
 117 %************************************************************************
 118
 119 \begin{code}
 120 rdrNameOcc :: RdrName -> OccName
 121 rdrNameOcc (Qual _ occ) = occ
 122 rdrNameOcc (Unqual occ) = occ
 123 rdrNameOcc (Orig _ occ) = occ
 124 rdrNameOcc (Exact name) = nameOccName name
 125
 126 rdrNameSpace :: RdrName -> NameSpace
 127 rdrNameSpace = occNameSpace . rdrNameOcc
 128
 129 setRdrNameSpace :: RdrName -> NameSpace -> RdrName
 130 -- ^ This rather gruesome function is used mainly by the parser.
 131 -- When parsing:
 132 --
 133 -- > data T a = T | T1 Int
 134 --
 135 -- we parse the data constructors as /types/ because of parser ambiguities,
 136 -- so then we need to change the /type constr/ to a /data constr/
 137 --
 138 -- The exact-name case /can/ occur when parsing:
 139 --
 140 -- > data [] a = [] | a : [a]
 141 --
 142 -- For the exact-name case we return an original name.
 143 setRdrNameSpace (Unqual occ) ns = Unqual (setOccNameSpace ns occ)
 144 setRdrNameSpace (Qual m occ) ns = Qual m (setOccNameSpace ns occ)
 145 setRdrNameSpace (Orig m occ) ns = Orig m (setOccNameSpace ns occ)
 146 setRdrNameSpace (Exact n)    ns = ASSERT( isExternalName n )
 147                                   Orig (nameModule n)
 148                                        (setOccNameSpace ns (nameOccName n))
 149 \end{code}
 150
 151 \begin{code}
 152         -- These two are the basic constructors
 153 mkRdrUnqual :: OccName -> RdrName
 154 mkRdrUnqual occ = Unqual occ
 155
 156 mkRdrQual :: ModuleName -> OccName -> RdrName
 157 mkRdrQual mod occ = Qual mod occ
 158
 159 mkOrig :: Module -> OccName -> RdrName
 160 mkOrig mod occ = Orig mod occ
 161
 162 ---------------
 163 -- | Produce an original 'RdrName' whose module that of a parent 'Name' but its 'OccName'
 164 -- is derived from that of it's parent using the supplied function
 165 mkDerivedRdrName :: Name -> (OccName -> OccName) -> RdrName
 166 mkDerivedRdrName parent mk_occ
 167   = ASSERT2( isExternalName parent, ppr parent )
 168     mkOrig (nameModule parent) (mk_occ (nameOccName parent))
 169
 170 ---------------
 171         -- These two are used when parsing source files
 172         -- They do encode the module and occurrence names
 173 mkUnqual :: NameSpace -> FastString -> RdrName
 174 mkUnqual sp n = Unqual (mkOccNameFS sp n)
 175
 176 mkVarUnqual :: FastString -> RdrName
 177 mkVarUnqual n = Unqual (mkVarOccFS n)
 178
 179 -- | Make a qualified 'RdrName' in the given namespace and where the 'ModuleName' and
 180 -- the 'OccName' are taken from the first and second elements of the tuple respectively
 181 mkQual :: NameSpace -> (FastString, FastString) -> RdrName
 182 mkQual sp (m, n) = Qual (mkModuleNameFS m) (mkOccNameFS sp n)
 183
 184 getRdrName :: NamedThing thing => thing -> RdrName
 185 getRdrName name = nameRdrName (getName name)
 186
 187 nameRdrName :: Name -> RdrName
 188 nameRdrName name = Exact name
 189 -- Keep the Name even for Internal names, so that the
 190 -- unique is still there for debug printing, particularly
 191 -- of Types (which are converted to IfaceTypes before printing)
 192
 193 nukeExact :: Name -> RdrName
 194 nukeExact n
 195   | isExternalName n = Orig (nameModule n) (nameOccName n)
 196   | otherwise        = Unqual (nameOccName n)
 197 \end{code}
 198
 199 \begin{code}
 200 isRdrDataCon :: RdrName -> Bool
 201 isRdrTyVar   :: RdrName -> Bool
 202 isRdrTc      :: RdrName -> Bool
 203
 204 isRdrDataCon rn = isDataOcc (rdrNameOcc rn)
 205 isRdrTyVar   rn = isTvOcc   (rdrNameOcc rn)
 206 isRdrTc      rn = isTcOcc   (rdrNameOcc rn)
 207
 208 isSrcRdrName :: RdrName -> Bool
 209 isSrcRdrName (Unqual _) = True
 210 isSrcRdrName (Qual _ _) = True
 211 isSrcRdrName _          = False
 212
 213 isUnqual :: RdrName -> Bool
 214 isUnqual (Unqual _) = True
 215 isUnqual _          = False
 216
 217 isQual :: RdrName -> Bool
 218 isQual (Qual _ _) = True
 219 isQual _          = False
 220
 221 isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
 222 isQual_maybe (Qual m n) = Just (m,n)
 223 isQual_maybe _          = Nothing
 224
 225 isOrig :: RdrName -> Bool
 226 isOrig (Orig _ _) = True
 227 isOrig _          = False
 228
 229 isOrig_maybe :: RdrName -> Maybe (Module, OccName)
 230 isOrig_maybe (Orig m n) = Just (m,n)
 231 isOrig_maybe _          = Nothing
 232
 233 isExact :: RdrName -> Bool
 234 isExact (Exact _) = True
 235 isExact _         = False
 236
 237 isExact_maybe :: RdrName -> Maybe Name
 238 isExact_maybe (Exact n) = Just n
 239 isExact_maybe _         = Nothing
 240 \end{code}
 241
 242
 243 %************************************************************************
 244 %*                                                                      *
 245 \subsection{Instances}
 246 %*                                                                      *
 247 %************************************************************************
 248
 249 \begin{code}
 250 instance Outputable RdrName where
 251     ppr (Exact name)   = ppr name
 252     ppr (Unqual occ)   = ppr occ
 253     ppr (Qual mod occ) = ppr mod <> dot <> ppr occ
 254     ppr (Orig mod occ) = getPprStyle (\sty -> pprModulePrefix sty mod occ <> ppr occ)
 255
 256 instance OutputableBndr RdrName where
 257     pprBndr _ n
 258         | isTvOcc (rdrNameOcc n) = char '@' <+> ppr n
 259         | otherwise              = ppr n
 260
 261 showRdrName :: RdrName -> String
 262 showRdrName r = showSDoc (ppr r)
 263
 264 instance Eq RdrName where
 265     (Exact n1)    == (Exact n2)    = n1==n2
 266         -- Convert exact to orig
 267     (Exact n1)    == r2@(Orig _ _) = nukeExact n1 == r2
 268     r1@(Orig _ _) == (Exact n2)    = r1 == nukeExact n2
 269
 270     (Orig m1 o1)  == (Orig m2 o2)  = m1==m2 && o1==o2
 271     (Qual m1 o1)  == (Qual m2 o2)  = m1==m2 && o1==o2
 272     (Unqual o1)   == (Unqual o2)   = o1==o2
 273     _             == _             = False
 274
 275 instance Ord RdrName where
 276     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
 277     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
 278     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
 279     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
 280
 281         -- Exact < Unqual < Qual < Orig
 282         -- [Note: Apr 2004] We used to use nukeExact to convert Exact to Orig
 283         --      before comparing so that Prelude.map == the exact Prelude.map, but
 284         --      that meant that we reported duplicates when renaming bindings
 285         --      generated by Template Haskell; e.g
 286         --      do { n1 <- newName "foo"; n2 <- newName "foo";
 287         --           <decl involving n1,n2> }
 288         --      I think we can do without this conversion
 289     compare (Exact n1) (Exact n2) = n1 `compare` n2
 290     compare (Exact _)  _          = LT
 291
 292     compare (Unqual _)   (Exact _)    = GT
 293     compare (Unqual o1)  (Unqual  o2) = o1 `compare` o2
 294     compare (Unqual _)   _            = LT
 295
 296     compare (Qual _ _)   (Exact _)    = GT
 297     compare (Qual _ _)   (Unqual _)   = GT
 298     compare (Qual m1 o1) (Qual m2 o2) = (o1 `compare` o2) `thenCmp` (m1 `compare` m2)
 299     compare (Qual _ _)   (Orig _ _)   = LT
 300
 301     compare (Orig m1 o1) (Orig m2 o2) = (o1 `compare` o2) `thenCmp` (m1 `compare` m2)
 302     compare (Orig _ _)   _            = GT
 303 \end{code}
 304
 305 %************************************************************************
 306 %*                                                                      *
 307                         LocalRdrEnv
 308 %*                                                                      *
 309 %************************************************************************
 310
 311 \begin{code}
 312 -- | This environment is used to store local bindings (@let@, @where@, lambda, @case@).
 313 -- It is keyed by OccName, because we never use it for qualified names
 314 type LocalRdrEnv = OccEnv Name
 315
 316 emptyLocalRdrEnv :: LocalRdrEnv
 317 emptyLocalRdrEnv = emptyOccEnv
 318
 319 extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
 320 extendLocalRdrEnv env name
 321   = extendOccEnv env (nameOccName name) name
 322
 323 extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
 324 extendLocalRdrEnvList env names
 325   = extendOccEnvList env [(nameOccName n, n) | n <- names]
 326
 327 lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
 328 lookupLocalRdrEnv _   (Exact name) = Just name
 329 lookupLocalRdrEnv env (Unqual occ) = lookupOccEnv env occ
 330 lookupLocalRdrEnv _   _            = Nothing
 331
 332 lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
 333 lookupLocalRdrOcc env occ = lookupOccEnv env occ
 334
 335 elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
 336 elemLocalRdrEnv rdr_name env
 337   | isUnqual rdr_name = rdrNameOcc rdr_name `elemOccEnv` env
 338   | otherwise         = False
 339 \end{code}
 340
 341 %************************************************************************
 342 %*                                                                      *
 343                         GlobalRdrEnv
 344 %*                                                                      *
 345 %************************************************************************
 346
 347 \begin{code}
 348 type GlobalRdrEnv = OccEnv [GlobalRdrElt]
 349 -- ^ Keyed by 'OccName'; when looking up a qualified name
 350 -- we look up the 'OccName' part, and then check the 'Provenance'
 351 -- to see if the appropriate qualification is valid.  This
 352 -- saves routinely doubling the size of the env by adding both
 353 -- qualified and unqualified names to the domain.
 354 --
 355 -- The list in the codomain is required because there may be name clashes
 356 -- These only get reported on lookup, not on construction
 357 --
 358 -- INVARIANT: All the members of the list have distinct
 359 --            'gre_name' fields; that is, no duplicate Names
 360 --
 361 -- INVARIANT: Imported provenance => Name is an ExternalName
 362 --            However LocalDefs can have an InternalName.  This
 363 --            happens only when type-checking a [d| ... |] Template
 364 --            Haskell quotation; see this note in RnNames
 365 --            Note [Top-level Names in Template Haskell decl quotes]
 366
 367 -- | An element of the 'GlobalRdrEnv'
 368 data GlobalRdrElt
 369   = GRE { gre_name :: Name,
 370           gre_par  :: Parent,
 371           gre_prov :: Provenance        -- ^ Why it's in scope
 372     }
 373
 374 -- | The children of a Name are the things that are abbreviated by the ".."
 375 --   notation in export lists.  Specifically:
 376 --      TyCon   Children are * data constructors
 377 --                           * record field ids
 378 --      Class   Children are * class operations
 379 -- Each child has the parent thing as its Parent
 380 data Parent = NoParent | ParentIs Name
 381               deriving (Eq)
 382
 383 instance Outputable Parent where
 384    ppr NoParent     = empty
 385    ppr (ParentIs n) = ptext (sLit "parent:") <> ppr n
 386
 387
 388 plusParent :: Parent -> Parent -> Parent
 389 plusParent p1 p2 = ASSERT2( p1 == p2, parens (ppr p1) <+> parens (ppr p2) )
 390                    p1
 391
 392 {- Why so complicated? -=chak
 393 plusParent :: Parent -> Parent -> Parent
 394 plusParent NoParent     rel =
 395   ASSERT2( case rel of { NoParent -> True; other -> False },
 396            ptext (sLit "plusParent[NoParent]: ") <+> ppr rel )
 397   NoParent
 398 plusParent (ParentIs n) rel =
 399   ASSERT2( case rel of { ParentIs m -> n==m;  other -> False },
 400            ptext (sLit "plusParent[ParentIs]:") <+> ppr n <> comma <+> ppr rel )
 401   ParentIs n
 402  -}
 403
 404 emptyGlobalRdrEnv :: GlobalRdrEnv
 405 emptyGlobalRdrEnv = emptyOccEnv
 406
 407 globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]
 408 globalRdrEnvElts env = foldOccEnv (++) [] env
 409
 410 instance Outputable GlobalRdrElt where
 411   ppr gre = ppr name <+> parens (ppr (gre_par gre) <+> pprNameProvenance gre)
 412           where
 413             name = gre_name gre
 414
 415 pprGlobalRdrEnv :: GlobalRdrEnv -> SDoc
 416 pprGlobalRdrEnv env
 417   = vcat (map pp (occEnvElts env))
 418   where
 419     pp gres = ppr (nameOccName (gre_name (head gres))) <> colon <+>
 420               vcat [ ppr (gre_name gre) <+> pprNameProvenance gre
 421                    | gre <- gres]
 422 \end{code}
 423
 424 \begin{code}
 425 lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]
 426 lookupGlobalRdrEnv env occ_name = case lookupOccEnv env occ_name of
 427                                         Nothing   -> []
 428                                         Just gres -> gres
 429
 430 extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
 431 extendGlobalRdrEnv env gre = extendOccEnv_C add env occ [gre]
 432   where
 433     occ = nameOccName (gre_name gre)
 434     add gres _ = gre:gres
 435
 436 lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
 437 lookupGRE_RdrName rdr_name env
 438   = case lookupOccEnv env (rdrNameOcc rdr_name) of
 439         Nothing   -> []
 440         Just gres -> pickGREs rdr_name gres
 441
 442 lookupGRE_Name :: GlobalRdrEnv -> Name -> [GlobalRdrElt]
 443 lookupGRE_Name env name
 444   = [ gre | gre <- lookupGlobalRdrEnv env (nameOccName name),
 445             gre_name gre == name ]
 446
 447 getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
 448 getGRE_NameQualifier_maybes env
 449   = map qualifier_maybe . map gre_prov . lookupGRE_Name env
 450   where qualifier_maybe LocalDef       = Nothing
 451         qualifier_maybe (Imported iss) = Just $ map (is_as . is_decl) iss
 452
 453 pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
 454 -- ^ Take a list of GREs which have the right OccName
 455 -- Pick those GREs that are suitable for this RdrName
 456 -- And for those, keep only only the Provenances that are suitable
 457 --
 458 -- Consider:
 459 --
 460 -- @
 461 --       module A ( f ) where
 462 --       import qualified Foo( f )
 463 --       import Baz( f )
 464 --       f = undefined
 465 -- @
 466 --
 467 -- Let's suppose that @Foo.f@ and @Baz.f@ are the same entity really.
 468 -- The export of @f@ is ambiguous because it's in scope from the local def
 469 -- and the import.  The lookup of @Unqual f@ should return a GRE for
 470 -- the locally-defined @f@, and a GRE for the imported @f@, with a /single/
 471 -- provenance, namely the one for @Baz(f)@.
 472 pickGREs rdr_name gres
 473   = mapCatMaybes pick gres
 474   where
 475     rdr_is_unqual = isUnqual rdr_name
 476     rdr_is_qual   = isQual_maybe rdr_name
 477
 478     pick :: GlobalRdrElt -> Maybe GlobalRdrElt
 479     pick gre@(GRE {gre_prov = LocalDef, gre_name = n})  -- Local def
 480         | rdr_is_unqual                    = Just gre
 481         | Just (mod,_) <- rdr_is_qual        -- Qualified name
 482         , Just n_mod <- nameModule_maybe n   -- Binder is External
 483         , mod == moduleName n_mod          = Just gre
 484         | otherwise                        = Nothing
 485     pick gre@(GRE {gre_prov = Imported [is]})   -- Single import (efficiency)
 486         | rdr_is_unqual,
 487           not (is_qual (is_decl is))    = Just gre
 488         | Just (mod,_) <- rdr_is_qual,
 489           mod == is_as (is_decl is)     = Just gre
 490         | otherwise                     = Nothing
 491     pick gre@(GRE {gre_prov = Imported is})     -- Multiple import
 492         | null filtered_is = Nothing
 493         | otherwise        = Just (gre {gre_prov = Imported filtered_is})
 494         where
 495           filtered_is | rdr_is_unqual
 496                       = filter (not . is_qual    . is_decl) is
 497                       | Just (mod,_) <- rdr_is_qual
 498                       = filter ((== mod) . is_as . is_decl) is
 499                       | otherwise
 500                       = []
 501
 502 isLocalGRE :: GlobalRdrElt -> Bool
 503 isLocalGRE (GRE {gre_prov = LocalDef}) = True
 504 isLocalGRE _                           = False
 505
 506 unQualOK :: GlobalRdrElt -> Bool
 507 -- ^ Test if an unqualifed version of this thing would be in scope
 508 unQualOK (GRE {gre_prov = LocalDef})    = True
 509 unQualOK (GRE {gre_prov = Imported is}) = any unQualSpecOK is
 510
 511 plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
 512 plusGlobalRdrEnv env1 env2 = plusOccEnv_C (foldr insertGRE) env1 env2
 513
 514 mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
 515 mkGlobalRdrEnv gres
 516   = foldr add emptyGlobalRdrEnv gres
 517   where
 518     add gre env = extendOccEnv_C (foldr insertGRE) env
 519                                  (nameOccName (gre_name gre))
 520                                  [gre]
 521
 522 findLocalDupsRdrEnv :: GlobalRdrEnv -> [OccName] -> (GlobalRdrEnv, [[Name]])
 523 -- ^ For each 'OccName', see if there are multiple local definitions
 524 -- for it.  If so, remove all but one (to suppress subsequent error messages)
 525 -- and return a list of the duplicate bindings
 526 findLocalDupsRdrEnv rdr_env occs
 527   = go rdr_env [] occs
 528   where
 529     go rdr_env dups [] = (rdr_env, dups)
 530     go rdr_env dups (occ:occs)
 531       = case filter isLocalGRE gres of
 532           []       -> WARN( True, ppr occ <+> ppr rdr_env )
 533                       go rdr_env dups occs      -- Weird!  No binding for occ
 534           [_]      -> go rdr_env dups occs      -- The common case
 535           dup_gres -> go (extendOccEnv rdr_env occ (head dup_gres : nonlocal_gres))
 536                          (map gre_name dup_gres : dups)
 537                          occs
 538       where
 539         gres = lookupOccEnv rdr_env occ `orElse` []
 540         nonlocal_gres = filterOut isLocalGRE gres
 541
 542
 543 insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
 544 insertGRE new_g [] = [new_g]
 545 insertGRE new_g (old_g : old_gs)
 546         | gre_name new_g == gre_name old_g
 547         = new_g `plusGRE` old_g : old_gs
 548         | otherwise
 549         = old_g : insertGRE new_g old_gs
 550
 551 plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
 552 -- Used when the gre_name fields match
 553 plusGRE g1 g2
 554   = GRE { gre_name = gre_name g1,
 555           gre_prov = gre_prov g1 `plusProv`   gre_prov g2,
 556           gre_par  = gre_par  g1 `plusParent` gre_par  g2 }
 557
 558 hideSomeUnquals :: GlobalRdrEnv -> [OccName] -> GlobalRdrEnv
 559 -- ^ Hide any unqualified bindings for the specified OccNames
 560 -- This is used in TH, when renaming a declaration bracket
 561 --
 562 -- > [d| foo = ... |]
 563 --
 564 -- We want unqualified @foo@ in "..." to mean this @foo@, not
 565 -- the one from the enclosing module.  But the /qualified/ name
 566 -- from the enclosing module must certainly still be available
 567
 568 --      Seems like 5 times as much work as it deserves!
 569 hideSomeUnquals rdr_env occs
 570   = foldr hide rdr_env occs
 571   where
 572     hide occ env
 573         | Just gres <- lookupOccEnv env occ = extendOccEnv env occ (map qual_gre gres)
 574         | otherwise                         = env
 575     qual_gre gre@(GRE { gre_name = name, gre_prov = LocalDef })
 576         = gre { gre_prov = Imported [imp_spec] }
 577         where   -- Local defs get transfomed to (fake) imported things
 578           mod = ASSERT2( isExternalName name, ppr name) moduleName (nameModule name)
 579           imp_spec = ImpSpec { is_item = ImpAll, is_decl = decl_spec }
 580           decl_spec = ImpDeclSpec { is_mod = mod, is_as = mod,
 581                                     is_qual = True,
 582                                     is_dloc = srcLocSpan (nameSrcLoc name) }
 583
 584     qual_gre gre@(GRE { gre_prov = Imported specs })
 585         = gre { gre_prov = Imported (map qual_spec specs) }
 586
 587     qual_spec spec@(ImpSpec { is_decl = decl_spec })
 588         = spec { is_decl = decl_spec { is_qual = True } }
 589 \end{code}
 590
 591 %************************************************************************
 592 %*                                                                      *
 593                         Provenance
 594 %*                                                                      *
 595 %************************************************************************
 596
 597 \begin{code}
 598 -- | The 'Provenance' of something says how it came to be in scope.
 599 -- It's quite elaborate so that we can give accurate unused-name warnings.
 600 data Provenance
 601   = LocalDef            -- ^ The thing was defined locally
 602   | Imported
 603         [ImportSpec]    -- ^ The thing was imported.
 604                         --
 605                         -- INVARIANT: the list of 'ImportSpec' is non-empty
 606
 607 data ImportSpec = ImpSpec { is_decl :: ImpDeclSpec,
 608                             is_item ::  ImpItemSpec }
 609                 deriving( Eq, Ord )
 610
 611 -- | Describes a particular import declaration and is
 612 -- shared among all the 'Provenance's for that decl
 613 data ImpDeclSpec
 614   = ImpDeclSpec {
 615         is_mod      :: ModuleName, -- ^ Module imported, e.g. @import Muggle@
 616                                    -- Note the @Muggle@ may well not be
 617                                    -- the defining module for this thing!
 618
 619                                    -- TODO: either should be Module, or there
 620                                    -- should be a Maybe PackageId here too.
 621         is_as       :: ModuleName, -- ^ Import alias, e.g. from @as M@ (or @Muggle@ if there is no @as@ clause)
 622         is_qual     :: Bool,       -- ^ Was this import qualified?
 623         is_dloc     :: SrcSpan     -- ^ The location of the entire import declaration
 624     }
 625
 626 -- | Describes import info a particular Name
 627 data ImpItemSpec
 628   = ImpAll              -- ^ The import had no import list,
 629                         -- or had a hiding list
 630
 631   | ImpSome {
 632         is_explicit :: Bool,
 633         is_iloc     :: SrcSpan  -- Location of the import item
 634     }   -- ^ The import had an import list.
 635         -- The 'is_explicit' field is @True@ iff the thing was named
 636         -- /explicitly/ in the import specs rather
 637         -- than being imported as part of a "..." group. Consider:
 638         --
 639         -- > import C( T(..) )
 640         --
 641         -- Here the constructors of @T@ are not named explicitly;
 642         -- only @T@ is named explicitly.
 643
 644 unQualSpecOK :: ImportSpec -> Bool
 645 -- ^ Is in scope unqualified?
 646 unQualSpecOK is = not (is_qual (is_decl is))
 647
 648 qualSpecOK :: ModuleName -> ImportSpec -> Bool
 649 -- ^ Is in scope qualified with the given module?
 650 qualSpecOK mod is = mod == is_as (is_decl is)
 651
 652 importSpecLoc :: ImportSpec -> SrcSpan
 653 importSpecLoc (ImpSpec decl ImpAll) = is_dloc decl
 654 importSpecLoc (ImpSpec _    item)   = is_iloc item
 655
 656 importSpecModule :: ImportSpec -> ModuleName
 657 importSpecModule is = is_mod (is_decl is)
 658
 659 isExplicitItem :: ImpItemSpec -> Bool
 660 isExplicitItem ImpAll                        = False
 661 isExplicitItem (ImpSome {is_explicit = exp}) = exp
 662
 663 -- Note [Comparing provenance]
 664 -- Comparison of provenance is just used for grouping
 665 -- error messages (in RnEnv.warnUnusedBinds)
 666 instance Eq Provenance where
 667   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
 668
 669 instance Eq ImpDeclSpec where
 670   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
 671
 672 instance Eq ImpItemSpec where
 673   p1 == p2 = case p1 `compare` p2 of EQ -> True; _ -> False
 674
 675 instance Ord Provenance where
 676    compare LocalDef      LocalDef        = EQ
 677    compare LocalDef      (Imported _)    = LT
 678    compare (Imported _ ) LocalDef        = GT
 679    compare (Imported is1) (Imported is2) = compare (head is1)
 680         {- See Note [Comparing provenance] -}      (head is2)
 681
 682 instance Ord ImpDeclSpec where
 683    compare is1 is2 = (is_mod is1 `compare` is_mod is2) `thenCmp`
 684                      (is_dloc is1 `compare` is_dloc is2)
 685
 686 instance Ord ImpItemSpec where
 687    compare is1 is2 = is_iloc is1 `compare` is_iloc is2
 688 \end{code}
 689
 690 \begin{code}
 691 plusProv :: Provenance -> Provenance -> Provenance
 692 -- Choose LocalDef over Imported
 693 -- There is an obscure bug lurking here; in the presence
 694 -- of recursive modules, something can be imported *and* locally
 695 -- defined, and one might refer to it with a qualified name from
 696 -- the import -- but I'm going to ignore that because it makes
 697 -- the isLocalGRE predicate so much nicer this way
 698 plusProv LocalDef        LocalDef        = panic "plusProv"
 699 plusProv LocalDef        _               = LocalDef
 700 plusProv _               LocalDef        = LocalDef
 701 plusProv (Imported is1)  (Imported is2)  = Imported (is1++is2)
 702
 703 pprNameProvenance :: GlobalRdrElt -> SDoc
 704 -- ^ Print out the place where the name was imported
 705 pprNameProvenance (GRE {gre_name = name, gre_prov = LocalDef})
 706   = ptext (sLit "defined at") <+> ppr (nameSrcLoc name)
 707 pprNameProvenance (GRE {gre_name = name, gre_prov = Imported whys})
 708   = case whys of
 709         (why:_) -> sep [ppr why, nest 2 (ppr_defn (nameSrcLoc name))]
 710         [] -> panic "pprNameProvenance"
 711
 712 -- If we know the exact definition point (which we may do with GHCi)
 713 -- then show that too.  But not if it's just "imported from X".
 714 ppr_defn :: SrcLoc -> SDoc
 715 ppr_defn loc | isGoodSrcLoc loc = parens (ptext (sLit "defined at") <+> ppr loc)
 716              | otherwise        = empty
 717
 718 instance Outputable ImportSpec where
 719    ppr imp_spec
 720      = ptext (sLit "imported from") <+> ppr (importSpecModule imp_spec)
 721         <+> if isGoodSrcSpan loc then ptext (sLit "at") <+> ppr loc
 722                                  else empty
 723      where
 724        loc = importSpecLoc imp_spec
 725 \end{code}