compiler/rename/RnEnv.lhs

   1 \%
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
   3 %
   4 \section[RnEnv]{Environment manipulation for the renamer monad}
   5
   6 \begin{code}
   7 {-# OPTIONS -w #-}
   8 -- The above warning supression flag is a temporary kludge.
   9 -- While working on this module you are encouraged to remove it and fix
  10 -- any warnings in the module. See
  11 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
  12 -- for details
  13
  14 module RnEnv (
  15         newTopSrcBinder, lookupFamInstDeclBndr,
  16         lookupLocatedBndrRn, lookupBndrRn, lookupBndrRn_maybe,
  17         lookupLocatedTopBndrRn, lookupTopBndrRn, lookupBndrRn_maybe,
  18         lookupLocatedOccRn, lookupOccRn,
  19         lookupLocatedGlobalOccRn, lookupGlobalOccRn,
  20         lookupLocalDataTcNames, lookupSrcOcc_maybe,
  21         lookupFixityRn, lookupTyFixityRn, lookupLocatedSigOccRn,
  22         lookupInstDeclBndr, lookupRecordBndr, lookupConstructorFields,
  23         lookupSyntaxName, lookupSyntaxTable, lookupImportedName,
  24         lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
  25         getLookupOccRn,
  26
  27         newLocalsRn, newIPNameRn,
  28         bindLocalNames, bindLocalNamesFV,
  29         MiniFixityEnv, bindLocalNamesFV_WithFixities,
  30         bindLocatedLocalsFV, bindLocatedLocalsRn,
  31         bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
  32         bindTyVarsRn, extendTyVarEnvFVRn,
  33         bindLocalFixities,
  34
  35         checkDupRdrNames, checkDupNames, checkShadowedNames,
  36         checkDupAndShadowedRdrNames,
  37         mapFvRn, mapFvRnCPS,
  38         warnUnusedMatches, warnUnusedModules, warnUnusedImports,
  39         warnUnusedTopBinds, warnUnusedLocalBinds,
  40         dataTcOccs, unknownNameErr
  41     ) where
  42
  43 #include "HsVersions.h"
  44
  45 import LoadIface        ( loadInterfaceForName, loadSrcInterface )
  46 import IfaceEnv         ( lookupOrig, newGlobalBinder, newIPName )
  47 import HsSyn            ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
  48                           LHsTyVarBndr, LHsType,
  49                           Fixity, hsLTyVarLocNames, replaceTyVarName )
  50 import RdrHsSyn         ( extractHsTyRdrTyVars )
  51 import RdrName
  52 import HscTypes         ( availNames, ModIface(..), FixItem(..), lookupFixity)
  53 import TcEnv            ( tcLookupDataCon )
  54 import TcRnMonad
  55 import Name             ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
  56                           nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
  57 import NameSet
  58 import NameEnv
  59 import LazyUniqFM
  60 import DataCon          ( dataConFieldLabels )
  61 import OccName
  62 import Module           ( Module, ModuleName )
  63 import PrelNames        ( mkUnboundName, rOOT_MAIN, iNTERACTIVE,
  64                           consDataConKey, hasKey, forall_tv_RDR )
  65 import UniqSupply
  66 import BasicTypes       ( IPName, mapIPName, Fixity )
  67 import SrcLoc           ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
  68                           srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
  69 import Outputable
  70 import Util
  71 import Maybes
  72 import ListSetOps       ( removeDups )
  73 import List             ( nubBy )
  74 import DynFlags
  75 import FastString
  76 import Control.Monad
  77 \end{code}
  78
  79 \begin{code}
  80 -- XXX
  81 thenM :: Monad a => a b -> (b -> a c) -> a c
  82 thenM = (>>=)
  83
  84 thenM_ :: Monad a => a b -> a c -> a c
  85 thenM_ = (>>)
  86
  87 returnM :: Monad m => a -> m a
  88 returnM = return
  89
  90 mappM :: (Monad m) => (a -> m b) -> [a] -> m [b]
  91 mappM = mapM
  92
  93 mappM_ :: (Monad m) => (a -> m b) -> [a] -> m ()
  94 mappM_ = mapM_
  95
  96 checkM :: Monad m => Bool -> m () -> m ()
  97 checkM = unless
  98 \end{code}
  99
 100 %*********************************************************
 101 %*                                                      *
 102                 Source-code binders
 103 %*                                                      *
 104 %*********************************************************
 105
 106 \begin{code}
 107 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
 108 newTopSrcBinder this_mod (L loc rdr_name)
 109   | Just name <- isExact_maybe rdr_name
 110   =     -- This is here to catch
 111         --   (a) Exact-name binders created by Template Haskell
 112         --   (b) The PrelBase defn of (say) [] and similar, for which
 113         --       the parser reads the special syntax and returns an Exact RdrName
 114         -- We are at a binding site for the name, so check first that it
 115         -- the current module is the correct one; otherwise GHC can get
 116         -- very confused indeed. This test rejects code like
 117         --      data T = (,) Int Int
 118         -- unless we are in GHC.Tup
 119     ASSERT2( isExternalName name,  ppr name )
 120     do  { checkM (this_mod == nameModule name)
 121                  (addErrAt loc (badOrigBinding rdr_name))
 122         ; return name }
 123
 124
 125   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
 126   = do  { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
 127                  (addErrAt loc (badOrigBinding rdr_name))
 128         -- When reading External Core we get Orig names as binders,
 129         -- but they should agree with the module gotten from the monad
 130         --
 131         -- We can get built-in syntax showing up here too, sadly.  If you type
 132         --      data T = (,,,)
 133         -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
 134         -- uses setRdrNameSpace to make it into a data constructors.  At that point
 135         -- the nice Exact name for the TyCon gets swizzled to an Orig name.
 136         -- Hence the badOrigBinding error message.
 137         --
 138         -- Except for the ":Main.main = ..." definition inserted into
 139         -- the Main module; ugh!
 140
 141         -- Because of this latter case, we call newGlobalBinder with a module from
 142         -- the RdrName, not from the environment.  In principle, it'd be fine to
 143         -- have an arbitrary mixture of external core definitions in a single module,
 144         -- (apart from module-initialisation issues, perhaps).
 145         ; newGlobalBinder rdr_mod rdr_occ loc }
 146                 --TODO, should pass the whole span
 147
 148   | otherwise
 149   = do  { checkM (not (isQual rdr_name))
 150                  (addErrAt loc (badQualBndrErr rdr_name))
 151                 -- Binders should not be qualified; if they are, and with a different
 152                 -- module name, we we get a confusing "M.T is not in scope" error later
 153         ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
 154 \end{code}
 155
 156 %*********************************************************
 157 %*                                                      *
 158         Source code occurrences
 159 %*                                                      *
 160 %*********************************************************
 161
 162 Looking up a name in the RnEnv.
 163
 164 \begin{code}
 165 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
 166 lookupLocatedBndrRn = wrapLocM lookupBndrRn
 167
 168 lookupBndrRn :: RdrName -> RnM Name
 169 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
 170                     case nopt of
 171                       Just n' -> return n'
 172                       Nothing -> do traceRn $ text "lookupTopBndrRn"
 173                                     unboundName n
 174
 175 lookupTopBndrRn :: RdrName -> RnM Name
 176 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
 177                        case nopt of
 178                          Just n' -> return n'
 179                          Nothing -> do traceRn $ text "lookupTopBndrRn"
 180                                        unboundName n
 181
 182 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
 183 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
 184 lookupBndrRn_maybe rdr_name
 185   = getLocalRdrEnv              `thenM` \ local_env ->
 186     case lookupLocalRdrEnv local_env rdr_name of
 187           Just name -> returnM (Just name)
 188           Nothing   -> lookupTopBndrRn_maybe rdr_name
 189
 190 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
 191 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
 192
 193 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
 194 -- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
 195 -- and there may be several imported 'f's too, which must not confuse us.
 196 -- For example, this is OK:
 197 --      import Foo( f )
 198 --      infix 9 f       -- The 'f' here does not need to be qualified
 199 --      f x = x         -- Nor here, of course
 200 -- So we have to filter out the non-local ones.
 201 --
 202 -- A separate function (importsFromLocalDecls) reports duplicate top level
 203 -- decls, so here it's safe just to choose an arbitrary one.
 204 --
 205 -- There should never be a qualified name in a binding position in Haskell,
 206 -- but there can be if we have read in an external-Core file.
 207 -- The Haskell parser checks for the illegal qualified name in Haskell
 208 -- source files, so we don't need to do so here.
 209
 210 lookupTopBndrRn_maybe rdr_name
 211   | Just name <- isExact_maybe rdr_name
 212   = returnM (Just name)
 213
 214   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
 215         -- This deals with the case of derived bindings, where
 216         -- we don't bother to call newTopSrcBinder first
 217         -- We assume there is no "parent" name
 218   = do  { loc <- getSrcSpanM
 219         ; n <- newGlobalBinder rdr_mod rdr_occ loc
 220         ; return (Just n)}
 221
 222   | otherwise
 223   = do  { mb_gre <- lookupGreLocalRn rdr_name
 224         ; case mb_gre of
 225                 Nothing  -> returnM Nothing
 226                 Just gre -> returnM (Just $ gre_name gre) }
 227
 228 -- lookupLocatedSigOccRn is used for type signatures and pragmas
 229 -- Is this valid?
 230 --   module A
 231 --      import M( f )
 232 --      f :: Int -> Int
 233 --      f x = x
 234 -- It's clear that the 'f' in the signature must refer to A.f
 235 -- The Haskell98 report does not stipulate this, but it will!
 236 -- So we must treat the 'f' in the signature in the same way
 237 -- as the binding occurrence of 'f', using lookupBndrRn
 238 --
 239 -- However, consider this case:
 240 --      import M( f )
 241 --      f :: Int -> Int
 242 --      g x = x
 243 -- We don't want to say 'f' is out of scope; instead, we want to
 244 -- return the imported 'f', so that later on the reanamer will
 245 -- correctly report "misplaced type sig".
 246 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
 247 lookupLocatedSigOccRn = wrapLocM $ \ rdr_name -> do
 248         { local_env <- getLocalRdrEnv
 249         ; case lookupLocalRdrEnv local_env rdr_name of {
 250                 Just n  -> return n ;
 251                 Nothing -> do
 252         { mb_gre <- lookupGreLocalRn rdr_name
 253         ; case mb_gre of
 254                 Just gre -> return (gre_name gre)
 255                 Nothing  -> lookupGlobalOccRn rdr_name
 256         }}}
 257
 258 -----------------------------------------------
 259 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
 260 -- This is called on the method name on the left-hand side of an
 261 -- instance declaration binding. eg.  instance Functor T where
 262 --                                       fmap = ...
 263 --                                       ^^^^ called on this
 264 -- Regardless of how many unqualified fmaps are in scope, we want
 265 -- the one that comes from the Functor class.
 266 --
 267 -- Furthermore, note that we take no account of whether the
 268 -- name is only in scope qualified.  I.e. even if method op is
 269 -- in scope as M.op, we still allow plain 'op' on the LHS of
 270 -- an instance decl
 271 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
 272   where
 273     doc = ptext SLIT("method of class") <+> quotes (ppr cls)
 274     is_op gre@(GRE {gre_par = ParentIs n}) = n == cls
 275     is_op other                            = False
 276
 277 -----------------------------------------------
 278 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
 279 -- Used for record construction and pattern matching
 280 -- When the -fdisambiguate-record-fields flag is on, take account of the
 281 -- constructor name to disambiguate which field to use; it's just the
 282 -- same as for instance decls
 283 lookupRecordBndr Nothing rdr_name
 284   = lookupLocatedGlobalOccRn rdr_name
 285 lookupRecordBndr (Just (L _ data_con)) rdr_name
 286   = do  { flag_on <- doptM Opt_DisambiguateRecordFields
 287         ; if not flag_on
 288           then lookupLocatedGlobalOccRn rdr_name
 289           else do {
 290           fields <- lookupConstructorFields data_con
 291         ; let is_field gre = gre_name gre `elem` fields
 292         ; lookup_located_sub_bndr is_field doc rdr_name
 293         }}
 294    where
 295      doc = ptext SLIT("field of constructor") <+> quotes (ppr data_con)
 296
 297
 298 lookupConstructorFields :: Name -> RnM [Name]
 299 -- Look up the fields of a given constructor
 300 --   *  For constructors from this module, use the record field env,
 301 --      which is itself gathered from the (as yet un-typechecked)
 302 --      data type decls
 303 --
 304 --    * For constructors from imported modules, use the *type* environment
 305 --      since imported modles are already compiled, the info is conveniently
 306 --      right there
 307
 308 lookupConstructorFields con_name
 309   = do  { this_mod <- getModule
 310         ; if nameIsLocalOrFrom this_mod con_name then
 311           do { field_env <- getRecFieldEnv
 312              ; return (lookupNameEnv field_env con_name `orElse` []) }
 313           else
 314           do { con <- tcLookupDataCon con_name
 315              ; return (dataConFieldLabels con) } }
 316
 317 -----------------------------------------------
 318 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
 319                         -> SDoc -> Located RdrName
 320                         -> RnM (Located Name)
 321 lookup_located_sub_bndr is_good doc rdr_name
 322   = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
 323
 324 lookup_sub_bndr is_good doc rdr_name
 325   | isUnqual rdr_name   -- Find all the things the rdr-name maps to
 326   = do  {               -- and pick the one with the right parent name
 327         ; env <- getGlobalRdrEnv
 328         ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
 329                 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
 330                 --     The latter does pickGREs, but we want to allow 'x'
 331                 --     even if only 'M.x' is in scope
 332             [gre] -> return (gre_name gre)
 333             []    -> do { addErr (unknownSubordinateErr doc rdr_name)
 334                         ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
 335                         ; return (mkUnboundName rdr_name) }
 336             gres  -> do { addNameClashErrRn rdr_name gres
 337                         ; return (gre_name (head gres)) }
 338         }
 339
 340   | otherwise   -- Occurs in derived instances, where we just
 341                 -- refer directly to the right method
 342   = ASSERT2( not (isQual rdr_name), ppr rdr_name )
 343           -- NB: qualified names are rejected by the parser
 344     lookupImportedName rdr_name
 345
 346 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
 347 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
 348
 349 -- Looking up family names in type instances is a subtle affair.  The family
 350 -- may be imported, in which case we need to lookup the occurence of a global
 351 -- name.  Alternatively, the family may be in the same binding group (and in
 352 -- fact in a declaration processed later), and we need to create a new top
 353 -- source binder.
 354 --
 355 -- So, also this is strictly speaking an occurence, we cannot raise an error
 356 -- message yet for instances without a family declaration.  This will happen
 357 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
 358 --
 359 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
 360 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
 361   = do { mb_gre <- lookupGreRn_maybe rdr_name
 362        ; case mb_gre of
 363            Just gre -> returnM (gre_name gre) ;
 364            Nothing  -> newTopSrcBinder mod lrdr_name }
 365
 366 --------------------------------------------------
 367 --              Occurrences
 368 --------------------------------------------------
 369
 370 getLookupOccRn :: RnM (Name -> Maybe Name)
 371 getLookupOccRn
 372   = getLocalRdrEnv                      `thenM` \ local_env ->
 373     return (lookupLocalRdrOcc local_env . nameOccName)
 374
 375 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
 376 lookupLocatedOccRn = wrapLocM lookupOccRn
 377
 378 -- lookupOccRn looks up an occurrence of a RdrName
 379 lookupOccRn :: RdrName -> RnM Name
 380 lookupOccRn rdr_name
 381   = getLocalRdrEnv                      `thenM` \ local_env ->
 382     case lookupLocalRdrEnv local_env rdr_name of
 383           Just name -> returnM name
 384           Nothing   -> lookupGlobalOccRn rdr_name
 385
 386 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
 387 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
 388
 389 lookupGlobalOccRn :: RdrName -> RnM Name
 390 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
 391 -- environment.  It's used only for
 392 --      record field names
 393 --      class op names in class and instance decls
 394
 395 lookupGlobalOccRn rdr_name
 396   | not (isSrcRdrName rdr_name)
 397   = lookupImportedName rdr_name
 398
 399   | otherwise
 400   =     -- First look up the name in the normal environment.
 401    lookupGreRn_maybe rdr_name           `thenM` \ mb_gre ->
 402    case mb_gre of {
 403         Just gre -> returnM (gre_name gre) ;
 404         Nothing   ->
 405
 406         -- We allow qualified names on the command line to refer to
 407         --  *any* name exported by any module in scope, just as if
 408         -- there was an "import qualified M" declaration for every
 409         -- module.
 410    getModule            `thenM` \ mod ->
 411    if isQual rdr_name && mod == iNTERACTIVE then
 412                                         -- This test is not expensive,
 413         lookupQualifiedName rdr_name    -- and only happens for failed lookups
 414    else do
 415         traceRn $ text "lookupGlobalOccRn"
 416         unboundName rdr_name }
 417
 418 lookupImportedName :: RdrName -> TcRnIf m n Name
 419 -- Lookup the occurrence of an imported name
 420 -- The RdrName is *always* qualified or Exact
 421 -- Treat it as an original name, and conjure up the Name
 422 -- Usually it's Exact or Orig, but it can be Qual if it
 423 --      comes from an hi-boot file.  (This minor infelicity is
 424 --      just to reduce duplication in the parser.)
 425 lookupImportedName rdr_name
 426   | Just n <- isExact_maybe rdr_name
 427         -- This happens in derived code
 428   = returnM n
 429
 430         -- Always Orig, even when reading a .hi-boot file
 431   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
 432   = lookupOrig rdr_mod rdr_occ
 433
 434   | otherwise
 435   = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
 436
 437 unboundName :: RdrName -> RnM Name
 438 unboundName rdr_name
 439   = do  { addErr (unknownNameErr rdr_name)
 440         ; env <- getGlobalRdrEnv;
 441         ; traceRn (vcat [unknownNameErr rdr_name,
 442                          ptext SLIT("Global envt is:"),
 443                          nest 3 (pprGlobalRdrEnv env)])
 444         ; returnM (mkUnboundName rdr_name) }
 445
 446 --------------------------------------------------
 447 --      Lookup in the Global RdrEnv of the module
 448 --------------------------------------------------
 449
 450 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
 451 -- No filter function; does not report an error on failure
 452 lookupSrcOcc_maybe rdr_name
 453   = do  { mb_gre <- lookupGreRn_maybe rdr_name
 454         ; case mb_gre of
 455                 Nothing  -> returnM Nothing
 456                 Just gre -> returnM (Just (gre_name gre)) }
 457
 458 -------------------------
 459 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
 460 -- Just look up the RdrName in the GlobalRdrEnv
 461 lookupGreRn_maybe rdr_name
 462   = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
 463
 464 lookupGreRn :: RdrName -> RnM GlobalRdrElt
 465 -- If not found, add error message, and return a fake GRE
 466 lookupGreRn rdr_name
 467   = do  { mb_gre <- lookupGreRn_maybe rdr_name
 468         ; case mb_gre of {
 469             Just gre -> return gre ;
 470             Nothing  -> do
 471         { traceRn $ text "lookupGreRn"
 472         ; name <- unboundName rdr_name
 473         ; return (GRE { gre_name = name, gre_par = NoParent,
 474                         gre_prov = LocalDef }) }}}
 475
 476 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
 477 -- Similar, but restricted to locally-defined things
 478 lookupGreLocalRn rdr_name
 479   = lookupGreRn_help rdr_name lookup_fn
 480   where
 481     lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
 482
 483 lookupGreRn_help :: RdrName                     -- Only used in error message
 484                  -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
 485                  -> RnM (Maybe GlobalRdrElt)
 486 -- Checks for exactly one match; reports deprecations
 487 -- Returns Nothing, without error, if too few
 488 lookupGreRn_help rdr_name lookup
 489   = do  { env <- getGlobalRdrEnv
 490         ; case lookup env of
 491             []    -> returnM Nothing
 492             [gre] -> returnM (Just gre)
 493             gres  -> do { addNameClashErrRn rdr_name gres
 494                         ; returnM (Just (head gres)) } }
 495
 496 ------------------------------
 497 --      GHCi support
 498 ------------------------------
 499
 500 -- A qualified name on the command line can refer to any module at all: we
 501 -- try to load the interface if we don't already have it.
 502 lookupQualifiedName :: RdrName -> RnM Name
 503 lookupQualifiedName rdr_name
 504   | Just (mod,occ) <- isQual_maybe rdr_name
 505    -- Note: we want to behave as we would for a source file import here,
 506    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
 507    = loadSrcInterface doc mod False     `thenM` \ iface ->
 508
 509    case  [ (mod,occ) |
 510            (mod,avails) <- mi_exports iface,
 511            avail        <- avails,
 512            name         <- availNames avail,
 513            name == occ ] of
 514       ((mod,occ):ns) -> ASSERT (null ns)
 515                         lookupOrig mod occ
 516       _ -> unboundName rdr_name
 517
 518   | otherwise
 519   = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
 520   where
 521     doc = ptext SLIT("Need to find") <+> ppr rdr_name
 522 \end{code}
 523
 524 %*********************************************************
 525 %*                                                      *
 526                 Fixities
 527 %*                                                      *
 528 %*********************************************************
 529
 530 \begin{code}
 531 lookupLocalDataTcNames :: RdrName -> RnM [Name]
 532 -- GHC extension: look up both the tycon and data con
 533 -- for con-like things
 534 -- Complain if neither is in scope
 535 lookupLocalDataTcNames rdr_name
 536   | Just n <- isExact_maybe rdr_name
 537         -- Special case for (:), which doesn't get into the GlobalRdrEnv
 538   = return [n]  -- For this we don't need to try the tycon too
 539   | otherwise
 540   = do  { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
 541         ; case [gre_name gre | Just gre <- mb_gres] of
 542             [] -> do {
 543                       -- run for error reporting
 544                     ; unboundName rdr_name
 545                       ; return [] }
 546             names -> return names
 547     }
 548
 549 --------------------------------
 550 type MiniFixityEnv = OccEnv (Located Fixity)
 551         -- Mini fixity env for the names we're about
 552         -- to bind, in a single binding group
 553         --
 554         -- We keep the location so that if we find
 555         -- a duplicate, we can report it sensibly
 556
 557 bindLocalFixities :: [FixitySig RdrName] -> (UniqFM (Located Fixity) -> RnM a) -> RnM a
 558 -- Used for nested fixity decls:
 559 --   bind the names that are in scope already;
 560 --   pass the rest to the continuation for later
 561 --      as a FastString->(Located Fixity) map
 562 --
 563 -- No need to worry about type constructors here,
 564 -- Should check for duplicates?
 565 bindLocalFixities fixes thing_inside
 566   | null fixes = thing_inside emptyUFM
 567   | otherwise  = do ls <- mappM rn_sig fixes
 568                     let (now, later) = nowAndLater ls
 569                     extendFixityEnv now $ thing_inside later
 570   where
 571     rn_sig (FixitySig lv@(L loc v) fix) = do
 572       vopt <- lookupBndrRn_maybe v
 573       case vopt of
 574         Just new_v -> returnM (Left (new_v, (FixItem (rdrNameOcc v) fix)))
 575         Nothing -> returnM (Right (occNameFS $ rdrNameOcc v, (L loc fix)))
 576
 577     nowAndLater :: [Either (Name, FixItem) (FastString, Located Fixity)]
 578                        -> ([(Name,FixItem)], UniqFM (Located Fixity))
 579     nowAndLater ls =
 580         foldr (\ cur -> \ (now, later) ->
 581                         case cur of
 582                           Left (n, f) -> ((n, f) : now, later)
 583                           Right (fs, f) -> (now, addToUFM later fs f))
 584               ([], emptyUFM) ls
 585
 586 -- Used for nested fixity decls to bind names along with their fixities.
 587 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
 588 -- Also check for unused binders
 589 bindLocalNamesFV_WithFixities :: [Name]
 590                               -> MiniFixityEnv
 591                               -> RnM (a, FreeVars) -> RnM (a, FreeVars)
 592 bindLocalNamesFV_WithFixities names fixities thing_inside
 593   = bindLocalNamesFV names $
 594     extendFixityEnv boundFixities $
 595     thing_inside
 596   where
 597     -- find the names that have fixity decls
 598     boundFixities = foldr
 599                         (\ name -> \ acc ->
 600                          -- check whether this name has a fixity decl
 601                           case lookupOccEnv fixities (nameOccName name) of
 602                                Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
 603                                Nothing -> acc) [] names
 604     -- bind the names; extend the fixity env; do the thing inside
 605 \end{code}
 606
 607 --------------------------------
 608 lookupFixity is a bit strange.
 609
 610 * Nested local fixity decls are put in the local fixity env, which we
 611   find with getFixtyEnv
 612
 613 * Imported fixities are found in the HIT or PIT
 614
 615 * Top-level fixity decls in this module may be for Names that are
 616     either  Global         (constructors, class operations)
 617     or      Local/Exported (everything else)
 618   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
 619   We put them all in the local fixity environment
 620
 621 \begin{code}
 622 lookupFixityRn :: Name -> RnM Fixity
 623 lookupFixityRn name
 624   = getModule                           `thenM` \ this_mod ->
 625     if nameIsLocalOrFrom this_mod name
 626     then do     -- It's defined in this module
 627       local_fix_env <- getFixityEnv
 628       traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
 629                vcat [ppr name, ppr local_fix_env])
 630       return $ lookupFixity local_fix_env name
 631     else        -- It's imported
 632       -- For imported names, we have to get their fixities by doing a
 633       -- loadInterfaceForName, and consulting the Ifaces that comes back
 634       -- from that, because the interface file for the Name might not
 635       -- have been loaded yet.  Why not?  Suppose you import module A,
 636       -- which exports a function 'f', thus;
 637       --        module CurrentModule where
 638       --          import A( f )
 639       --        module A( f ) where
 640       --          import B( f )
 641       -- Then B isn't loaded right away (after all, it's possible that
 642       -- nothing from B will be used).  When we come across a use of
 643       -- 'f', we need to know its fixity, and it's then, and only
 644       -- then, that we load B.hi.  That is what's happening here.
 645       --
 646       -- loadInterfaceForName will find B.hi even if B is a hidden module,
 647       -- and that's what we want.
 648         loadInterfaceForName doc name   `thenM` \ iface -> do {
 649           traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
 650                    vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
 651            returnM (mi_fix_fn iface (nameOccName name))
 652                                                            }
 653   where
 654     doc = ptext SLIT("Checking fixity for") <+> ppr name
 655
 656 ---------------
 657 lookupTyFixityRn :: Located Name -> RnM Fixity
 658 lookupTyFixityRn (L loc n) = lookupFixityRn n
 659
 660 ---------------
 661 dataTcOccs :: RdrName -> [RdrName]
 662 -- If the input is a data constructor, return both it and a type
 663 -- constructor.  This is useful when we aren't sure which we are
 664 -- looking at.
 665 dataTcOccs rdr_name
 666   | Just n <- isExact_maybe rdr_name            -- Ghastly special case
 667   , n `hasKey` consDataConKey = [rdr_name]      -- see note below
 668   | isDataOcc occ             = [rdr_name_tc, rdr_name]
 669   | otherwise                 = [rdr_name]
 670   where
 671     occ         = rdrNameOcc rdr_name
 672     rdr_name_tc = setRdrNameSpace rdr_name tcName
 673
 674 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
 675 -- and setRdrNameSpace generates an Orig, which is fine
 676 -- But it's not fine for (:), because there *is* no corresponding type
 677 -- constructor.  If we generate an Orig tycon for GHC.Base.(:), it'll
 678 -- appear to be in scope (because Orig's simply allocate a new name-cache
 679 -- entry) and then we get an error when we use dataTcOccs in
 680 -- TcRnDriver.tcRnGetInfo.  Large sigh.
 681 \end{code}
 682
 683 %************************************************************************
 684 %*                                                                      *
 685                         Rebindable names
 686         Dealing with rebindable syntax is driven by the
 687         Opt_NoImplicitPrelude dynamic flag.
 688
 689         In "deriving" code we don't want to use rebindable syntax
 690         so we switch off the flag locally
 691
 692 %*                                                                      *
 693 %************************************************************************
 694
 695 Haskell 98 says that when you say "3" you get the "fromInteger" from the
 696 Standard Prelude, regardless of what is in scope.   However, to experiment
 697 with having a language that is less coupled to the standard prelude, we're
 698 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
 699 happens to be in scope.  Then you can
 700         import Prelude ()
 701         import MyPrelude as Prelude
 702 to get the desired effect.
 703
 704 At the moment this just happens for
 705   * fromInteger, fromRational on literals (in expressions and patterns)
 706   * negate (in expressions)
 707   * minus  (arising from n+k patterns)
 708   * "do" notation
 709
 710 We store the relevant Name in the HsSyn tree, in
 711   * HsIntegral/HsFractional/HsIsString
 712   * NegApp
 713   * NPlusKPat
 714   * HsDo
 715 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
 716 fromRationalName etc), but the renamer changes this to the appropriate user
 717 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
 718
 719 We treat the orignal (standard) names as free-vars too, because the type checker
 720 checks the type of the user thing against the type of the standard thing.
 721
 722 \begin{code}
 723 lookupSyntaxName :: Name                                -- The standard name
 724                  -> RnM (SyntaxExpr Name, FreeVars)     -- Possibly a non-standard name
 725 lookupSyntaxName std_name
 726   = doptM Opt_ImplicitPrelude           `thenM` \ implicit_prelude ->
 727     if implicit_prelude then normal_case
 728     else
 729         -- Get the similarly named thing from the local environment
 730     lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
 731     returnM (HsVar usr_name, unitFV usr_name)
 732   where
 733     normal_case = returnM (HsVar std_name, emptyFVs)
 734
 735 lookupSyntaxTable :: [Name]                             -- Standard names
 736                   -> RnM (SyntaxTable Name, FreeVars)   -- See comments with HsExpr.ReboundNames
 737 lookupSyntaxTable std_names
 738   = doptM Opt_ImplicitPrelude           `thenM` \ implicit_prelude ->
 739     if implicit_prelude then normal_case
 740     else
 741         -- Get the similarly named thing from the local environment
 742     mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names   `thenM` \ usr_names ->
 743
 744     returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
 745   where
 746     normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
 747 \end{code}
 748
 749
 750 %*********************************************************
 751 %*                                                      *
 752 \subsection{Binding}
 753 %*                                                      *
 754 %*********************************************************
 755
 756 \begin{code}
 757 newLocalsRn :: [Located RdrName] -> RnM [Name]
 758 newLocalsRn rdr_names_w_loc
 759   = newUniqueSupply             `thenM` \ us ->
 760     returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
 761   where
 762     mk (L loc rdr_name) uniq
 763         | Just name <- isExact_maybe rdr_name = name
 764                 -- This happens in code generated by Template Haskell
 765         | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
 766                         -- We only bind unqualified names here
 767                         -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
 768                       mkInternalName uniq (rdrNameOcc rdr_name) loc
 769
 770 ---------------------
 771 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
 772 checkDupAndShadowedRdrNames doc loc_rdr_names
 773   = do  { checkDupRdrNames doc loc_rdr_names
 774         ; envs <- getRdrEnvs
 775         ; checkShadowedNames doc envs
 776                 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
 777
 778 ---------------------
 779 bindLocatedLocalsRn :: SDoc     -- Documentation string for error message
 780                         -> [Located RdrName]
 781                     -> ([Name] -> RnM a)
 782                     -> RnM a
 783 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
 784   = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
 785
 786         -- Make fresh Names and extend the environment
 787     newLocalsRn rdr_names_w_loc         `thenM` \names ->
 788     bindLocalNames names (enclosed_scope names)
 789
 790 bindLocalNames :: [Name] -> RnM a -> RnM a
 791 bindLocalNames names enclosed_scope
 792   = getLocalRdrEnv              `thenM` \ name_env ->
 793     setLocalRdrEnv (extendLocalRdrEnv name_env names)
 794                     enclosed_scope
 795
 796 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
 797 bindLocalNamesFV names enclosed_scope
 798   = do  { (result, fvs) <- bindLocalNames names enclosed_scope
 799         ; returnM (result, delListFromNameSet fvs names) }
 800
 801
 802 -------------------------------------
 803         -- binLocalsFVRn is the same as bindLocalsRn
 804         -- except that it deals with free vars
 805 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
 806                     -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
 807 bindLocatedLocalsFV doc rdr_names enclosed_scope
 808   = bindLocatedLocalsRn doc rdr_names   $ \ names ->
 809     enclosed_scope names                `thenM` \ (thing, fvs) ->
 810     returnM (thing, delListFromNameSet fvs names)
 811
 812 -------------------------------------
 813 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
 814               -> ([LHsTyVarBndr Name] -> RnM a)
 815               -> RnM a
 816 -- Haskell-98 binding of type variables; e.g. within a data type decl
 817 bindTyVarsRn doc_str tyvar_names enclosed_scope
 818   = let
 819         located_tyvars = hsLTyVarLocNames tyvar_names
 820     in
 821     bindLocatedLocalsRn doc_str located_tyvars  $ \ names ->
 822     enclosed_scope (zipWith replace tyvar_names names)
 823     where
 824         replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
 825
 826 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
 827   -- Find the type variables in the pattern type
 828   -- signatures that must be brought into scope
 829 bindPatSigTyVars tys thing_inside
 830   = do  { scoped_tyvars <- doptM Opt_ScopedTypeVariables
 831         ; if not scoped_tyvars then
 832                 thing_inside []
 833           else
 834     do  { name_env <- getLocalRdrEnv
 835         ; let locd_tvs  = [ tv | ty <- tys
 836                                , tv <- extractHsTyRdrTyVars ty
 837                                , not (unLoc tv `elemLocalRdrEnv` name_env) ]
 838               nubbed_tvs = nubBy eqLocated locd_tvs
 839                 -- The 'nub' is important.  For example:
 840                 --      f (x :: t) (y :: t) = ....
 841                 -- We don't want to complain about binding t twice!
 842
 843         ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
 844   where
 845     doc_sig = text "In a pattern type-signature"
 846
 847 bindPatSigTyVarsFV :: [LHsType RdrName]
 848                    -> RnM (a, FreeVars)
 849                    -> RnM (a, FreeVars)
 850 bindPatSigTyVarsFV tys thing_inside
 851   = bindPatSigTyVars tys        $ \ tvs ->
 852     thing_inside                `thenM` \ (result,fvs) ->
 853     returnM (result, fvs `delListFromNameSet` tvs)
 854
 855 bindSigTyVarsFV :: [Name]
 856                 -> RnM (a, FreeVars)
 857                 -> RnM (a, FreeVars)
 858 bindSigTyVarsFV tvs thing_inside
 859   = do  { scoped_tyvars <- doptM Opt_ScopedTypeVariables
 860         ; if not scoped_tyvars then
 861                 thing_inside
 862           else
 863                 bindLocalNamesFV tvs thing_inside }
 864
 865 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
 866         -- This function is used only in rnSourceDecl on InstDecl
 867 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
 868
 869 -------------------------------------
 870 checkDupRdrNames :: SDoc
 871                  -> [Located RdrName]
 872                  -> RnM ()
 873 checkDupRdrNames doc_str rdr_names_w_loc
 874   =     -- Check for duplicated names in a binding group
 875     mappM_ (dupNamesErr getLoc doc_str) dups
 876   where
 877     (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
 878
 879 checkDupNames :: SDoc
 880               -> [Name]
 881               -> RnM ()
 882 checkDupNames doc_str names
 883   =     -- Check for duplicated names in a binding group
 884     mappM_ (dupNamesErr nameSrcSpan doc_str) dups
 885   where
 886     (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
 887
 888 -------------------------------------
 889 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
 890 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
 891   = ifOptM Opt_WarnNameShadowing $
 892     do  { traceRn (text "shadow" <+> ppr loc_rdr_names)
 893         ; mappM_ check_shadow loc_rdr_names }
 894   where
 895     check_shadow (loc, occ)
 896         | Just n <- mb_local = complain [ptext SLIT("bound at") <+> ppr (nameSrcLoc n)]
 897         | not (null gres)    = complain (map pprNameProvenance gres)
 898         | otherwise          = return ()
 899         where
 900           complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
 901           mb_local = lookupLocalRdrOcc local_env occ
 902           gres     = lookupGRE_RdrName (mkRdrUnqual occ) global_env
 903                 -- Make an Unqualified RdrName and look that up, so that
 904                 -- we don't find any GREs that are in scope qualified-only
 905 \end{code}
 906
 907
 908 %************************************************************************
 909 %*                                                                      *
 910 \subsection{Free variable manipulation}
 911 %*                                                                      *
 912 %************************************************************************
 913
 914 \begin{code}
 915 -- A useful utility
 916 mapFvRn f xs = mappM f xs       `thenM` \ stuff ->
 917                let
 918                   (ys, fvs_s) = unzip stuff
 919                in
 920                returnM (ys, plusFVs fvs_s)
 921
 922 -- because some of the rename functions are CPSed:
 923 -- maps the function across the list from left to right;
 924 -- collects all the free vars into one set
 925 mapFvRnCPS :: (a  -> (b   -> RnM c) -> RnM c)
 926            -> [a] -> ([b] -> RnM c) -> RnM c
 927
 928 mapFvRnCPS _ []     cont = cont []
 929 mapFvRnCPS f (x:xs) cont = f x             $ \ x' ->
 930                            mapFvRnCPS f xs $ \ xs' ->
 931                            cont (x':xs')
 932 \end{code}
 933
 934
 935 %************************************************************************
 936 %*                                                                      *
 937 \subsection{Envt utility functions}
 938 %*                                                                      *
 939 %************************************************************************
 940
 941 \begin{code}
 942 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
 943 warnUnusedModules mods
 944   = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
 945   where
 946     bleat (mod,loc) = addWarnAt loc (mk_warn mod)
 947     mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
 948                         <+> text "is imported, but nothing from it is used,",
 949                       nest 2 (ptext SLIT("except perhaps instances visible in")
 950                         <+> quotes (ppr m)),
 951                       ptext SLIT("To suppress this warning, use:")
 952                         <+> ptext SLIT("import") <+> ppr m <> parens empty ]
 953
 954
 955 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
 956 warnUnusedImports gres  = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
 957 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds   (warnUnusedGREs gres)
 958
 959 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
 960 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
 961 warnUnusedMatches    = check_unused Opt_WarnUnusedMatches
 962
 963 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
 964 check_unused flag bound_names used_names
 965  = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
 966
 967 -------------------------
 968 --      Helpers
 969 warnUnusedGREs gres
 970  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
 971
 972 warnUnusedLocals names
 973  = warnUnusedBinds [(n,LocalDef) | n<-names]
 974
 975 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
 976 warnUnusedBinds names  = mappM_ warnUnusedName (filter reportable names)
 977  where reportable (name,_)
 978         | isWiredInName name = False    -- Don't report unused wired-in names
 979                                         -- Otherwise we get a zillion warnings
 980                                         -- from Data.Tuple
 981         | otherwise = reportIfUnused (nameOccName name)
 982
 983 -------------------------
 984
 985 warnUnusedName :: (Name, Provenance) -> RnM ()
 986 warnUnusedName (name, LocalDef)
 987   = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
 988                      (ptext SLIT("Defined but not used"))
 989
 990 warnUnusedName (name, Imported is)
 991   = mapM_ warn is
 992   where
 993     warn spec = addUnusedWarning name span msg
 994         where
 995            span = importSpecLoc spec
 996            pp_mod = quotes (ppr (importSpecModule spec))
 997            msg = ptext SLIT("Imported from") <+> pp_mod <+> ptext SLIT("but not used")
 998
 999 addUnusedWarning name span msg
1000   = addWarnAt span $
1001     sep [msg <> colon,
1002          nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1003                         <+> quotes (ppr name)]
1004 \end{code}
1005
1006 \begin{code}
1007 addNameClashErrRn rdr_name names
1008   = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
1009                   ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
1010   where
1011     (np1:nps) = names
1012     msg1 = ptext  SLIT("either") <+> mk_ref np1
1013     msgs = [ptext SLIT("    or") <+> mk_ref np | np <- nps]
1014     mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1015
1016 shadowedNameWarn doc occ shadowed_locs
1017   = sep [ptext SLIT("This binding for") <+> quotes (ppr occ)
1018             <+> ptext SLIT("shadows the existing binding") <> plural shadowed_locs,
1019          nest 2 (vcat shadowed_locs)]
1020     $$ doc
1021
1022 unknownNameErr rdr_name
1023   = vcat [ hang (ptext SLIT("Not in scope:"))
1024               2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1025                           <+> quotes (ppr rdr_name))
1026          , extra ]
1027   where
1028     extra | rdr_name == forall_tv_RDR
1029           = ptext SLIT("Perhaps you intended to use -XRankNTypes or similar flag")
1030           | otherwise = empty
1031
1032 unknownSubordinateErr doc op    -- Doc is "method of class" or
1033                                 -- "field of constructor"
1034   = quotes (ppr op) <+> ptext SLIT("is not a (visible)") <+> doc
1035
1036 badOrigBinding name
1037   = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1038         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1039
1040 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1041 dupNamesErr get_loc descriptor names
1042   = addErrAt big_loc $
1043     vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr (head names)),
1044           locations, descriptor]
1045   where
1046     locs      = map get_loc names
1047     big_loc   = foldr1 combineSrcSpans locs
1048     one_line  = isOneLineSpan big_loc
1049     locations | one_line  = empty
1050               | otherwise = ptext SLIT("Bound at:") <+>
1051                             vcat (map ppr (sortLe (<=) locs))
1052
1053 badQualBndrErr rdr_name
1054   = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name
1055 \end{code}