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