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