ghc/compiler/rename/RnEnv.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[RnEnv]{Environment manipulation for the renamer monad}
   5
   6 \begin{code}
   7 module RnEnv where              -- Export everything
   8
   9 #include "HsVersions.h"
  10
  11 import {-# SOURCE #-} RnHiFiles( loadInterface )
  12
  13 import FlattenInfo      ( namesNeededForFlattening )
  14 import HsSyn
  15 import RdrHsSyn         ( RdrNameHsType, RdrNameFixitySig, extractHsTyRdrTyVars )
  16 import RdrName          ( RdrName, rdrNameModule, rdrNameOcc, isQual, isUnqual, isOrig,
  17                           mkRdrUnqual, mkRdrQual, setRdrNameSpace, rdrNameOcc,
  18                           lookupRdrEnv, rdrEnvToList, elemRdrEnv,
  19                           extendRdrEnv, addListToRdrEnv, emptyRdrEnv,
  20                           isExact_maybe, unqualifyRdrName
  21                         )
  22 import HsTypes          ( hsTyVarName, replaceTyVarName )
  23 import HscTypes         ( Provenance(..), pprNameProvenance, hasBetterProv,
  24                           ImportReason(..), GlobalRdrEnv, GlobalRdrElt(..),
  25                           GenAvailInfo(..), AvailInfo, Avails,
  26                           ModIface(..), NameCache(..), OrigNameCache,
  27                           Deprecations(..), lookupDeprec, isLocalGRE,
  28                           extendLocalRdrEnv, availName, availNames,
  29                           lookupFixity
  30                         )
  31 import TcRnMonad
  32 import Name             ( Name, getName, nameIsLocalOrFrom,
  33                           isWiredInName, mkInternalName, mkExternalName, mkIPName,
  34                           nameSrcLoc, nameOccName, setNameSrcLoc, nameModule    )
  35 import NameSet
  36 import OccName          ( OccName, tcName, isDataOcc, occNameFlavour, reportIfUnused )
  37 import Module           ( Module, ModuleName, moduleName, mkHomeModule,
  38                           lookupModuleEnv, lookupModuleEnvByName, extendModuleEnv_C )
  39 import PrelNames        ( mkUnboundName, intTyConName,
  40                           boolTyConName, funTyConName,
  41                           unpackCStringName, unpackCStringFoldrName, unpackCStringUtf8Name,
  42                           eqStringName, printName,
  43                           bindIOName, returnIOName, failIOName, thenIOName
  44                         )
  45 #ifdef GHCI
  46 import DsMeta           ( templateHaskellNames, qTyConName )
  47 #endif
  48 import TysWiredIn       ( unitTyCon )   -- A little odd
  49 import Finder           ( findModule )
  50 import FiniteMap
  51 import UniqSupply
  52 import SrcLoc           ( SrcLoc, importedSrcLoc )
  53 import Outputable
  54 import ListSetOps       ( removeDups, equivClasses )
  55 import BasicTypes       ( mapIPName, FixitySig(..) )
  56 import List             ( nub )
  57 import CmdLineOpts
  58 import FastString       ( FastString )
  59 \end{code}
  60
  61 %*********************************************************
  62 %*                                                      *
  63 \subsection{Making new names}
  64 %*                                                      *
  65 %*********************************************************
  66
  67 \begin{code}
  68 newTopBinder :: Module -> RdrName -> SrcLoc -> TcRn m Name
  69 newTopBinder mod rdr_name loc
  70   | Just name <- isExact_maybe rdr_name
  71   = returnM name
  72
  73   | otherwise
  74   = ASSERT( not (isOrig rdr_name) || rdrNameModule rdr_name == moduleName mod )
  75         -- When reading External Core we get Orig names as binders,
  76         -- but they should agree with the module gotten from the monad
  77     newGlobalName mod (rdrNameOcc rdr_name) loc
  78
  79 newGlobalName :: Module -> OccName -> SrcLoc -> TcRn m Name
  80 newGlobalName mod occ loc
  81   =     -- First check the cache
  82     getNameCache                `thenM` \ name_supply ->
  83     case lookupOrigNameCache (nsNames name_supply) mod occ of
  84
  85         -- A hit in the cache!  We are at the binding site of the name.
  86         -- This is the moment when we know the defining SrcLoc
  87         -- of the Name, so we set the SrcLoc of the name we return.
  88         --
  89         -- Main reason: then (bogus) multiple bindings of the same Name
  90         --              get different SrcLocs can can be reported as such.
  91         --
  92         -- Possible other reason: it might be in the cache because we
  93         --      encountered an occurrence before the binding site for an
  94         --      implicitly-imported Name.  Perhaps the current SrcLoc is
  95         --      better... but not really: it'll still just say 'imported'
  96         --
  97         -- IMPORTANT: Don't mess with wired-in names.
  98         --            Their wired-in-ness is in the SrcLoc
  99
 100         Just name | isWiredInName name -> returnM name
 101                   | otherwise          -> returnM (setNameSrcLoc name loc)
 102
 103         -- Miss in the cache!
 104         -- Build a completely new Name, and put it in the cache
 105         Nothing -> addNewName name_supply mod occ loc
 106
 107 -- Look up a "system name" in the name cache.
 108 -- This is done by the type checker...
 109 lookupSysName :: Name                   -- Base name
 110               -> (OccName -> OccName)   -- Occurrence name modifier
 111               -> TcRn m Name            -- System name
 112 lookupSysName base_name mk_sys_occ
 113   = newGlobalName (nameModule base_name)
 114                   (mk_sys_occ (nameOccName base_name))
 115                   (nameSrcLoc base_name)
 116
 117
 118 newGlobalNameFromRdrName rdr_name               -- Qualified original name
 119  = newGlobalName2 (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
 120
 121 newGlobalName2 :: ModuleName -> OccName -> TcRn m Name
 122   -- This one starts with a ModuleName, not a Module, because
 123   -- we may be simply looking at an occurrence M.x in an interface file.
 124   --
 125   -- Used for *occurrences*.  Even if we get a miss in the
 126   -- original-name cache, we make a new External Name.
 127   -- We get its Module either from the OrigNameCache, or (if this
 128   -- is the first Name from that module) from the Finder
 129   --
 130   -- In the case of a miss, we have to make up the SrcLoc, but that's
 131   -- OK: it must be an implicitly-imported Name, and that never occurs
 132   -- in an error message.
 133
 134 newGlobalName2 mod_name occ
 135   = getNameCache                `thenM` \ name_supply ->
 136     let
 137         new_name mod = addNewName name_supply mod occ importedSrcLoc
 138     in
 139     case lookupModuleEnvByName (nsNames name_supply) mod_name of
 140       Just (mod, occ_env) ->
 141         -- There are some names from this module already
 142         -- Next, look up in the OccNameEnv
 143         case lookupFM occ_env occ of
 144              Just name -> returnM name
 145              Nothing   -> new_name mod
 146
 147       Nothing   ->      -- No names from this module yet
 148         ioToTcRn (findModule mod_name)          `thenM` \ mb_loc ->
 149         case mb_loc of
 150             Right (mod, _) -> new_name mod
 151             Left files     ->
 152                 getDOpts `thenM` \ dflags ->
 153                 addErr (noIfaceErr dflags mod_name False files) `thenM_`
 154                         -- Things have really gone wrong at this point,
 155                         -- so having the wrong package info in the
 156                         -- Module is the least of our worries.
 157                 new_name (mkHomeModule mod_name)
 158
 159
 160 newIPName rdr_name_ip
 161   = getNameCache                `thenM` \ name_supply ->
 162     let
 163         ipcache = nsIPs name_supply
 164     in
 165     case lookupFM ipcache key of
 166         Just name_ip -> returnM name_ip
 167         Nothing      -> setNameCache new_ns     `thenM_`
 168                         returnM name_ip
 169                   where
 170                      (us', us1)  = splitUniqSupply (nsUniqs name_supply)
 171                      uniq        = uniqFromSupply us1
 172                      name_ip     = mapIPName mk_name rdr_name_ip
 173                      mk_name rdr_name = mkIPName uniq (rdrNameOcc rdr_name)
 174                      new_ipcache = addToFM ipcache key name_ip
 175                      new_ns      = name_supply {nsUniqs = us', nsIPs = new_ipcache}
 176     where
 177         key = rdr_name_ip       -- Ensures that ?x and %x get distinct Names
 178
 179 -- A local helper function
 180 addNewName name_supply mod occ loc
 181   = setNameCache new_name_supply        `thenM_`
 182     returnM name
 183   where
 184     (new_name_supply, name) = newExternalName name_supply mod occ loc
 185
 186
 187 newExternalName :: NameCache -> Module -> OccName -> SrcLoc
 188                   -> (NameCache,Name)
 189 -- Allocate a new unique, manufacture a new External Name,
 190 -- put it in the cache, and return the two
 191 newExternalName name_supply mod occ loc
 192   = (new_name_supply, name)
 193   where
 194      (us', us1)      = splitUniqSupply (nsUniqs name_supply)
 195      uniq            = uniqFromSupply us1
 196      name            = mkExternalName uniq mod occ loc
 197      new_cache       = extend_name_cache (nsNames name_supply) mod occ name
 198      new_name_supply = name_supply {nsUniqs = us', nsNames = new_cache}
 199
 200 lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name
 201 lookupOrigNameCache nc mod occ
 202   = case lookupModuleEnv nc mod of
 203         Nothing           -> Nothing
 204         Just (_, occ_env) -> lookupFM occ_env occ
 205
 206 extendOrigNameCache :: OrigNameCache -> Name -> OrigNameCache
 207 extendOrigNameCache nc name
 208   = extend_name_cache nc (nameModule name) (nameOccName name) name
 209
 210 extend_name_cache :: OrigNameCache -> Module -> OccName -> Name -> OrigNameCache
 211 extend_name_cache nc mod occ name
 212   = extendModuleEnv_C combine nc mod (mod, unitFM occ name)
 213   where
 214     combine (mod, occ_env) _ = (mod, addToFM occ_env occ name)
 215 \end{code}
 216
 217 %*********************************************************
 218 %*                                                      *
 219 \subsection{Looking up names}
 220 %*                                                      *
 221 %*********************************************************
 222
 223 Looking up a name in the RnEnv.
 224
 225 \begin{code}
 226 lookupBndrRn rdr_name
 227   = getLocalRdrEnv              `thenM` \ local_env ->
 228     case lookupRdrEnv local_env rdr_name of
 229           Just name -> returnM name
 230           Nothing   -> lookupTopBndrRn rdr_name
 231
 232 lookupTopBndrRn rdr_name
 233 -- Look up a top-level local binder.   We may be looking up an unqualified 'f',
 234 -- and there may be several imported 'f's too, which must not confuse us.
 235 -- So we have to filter out the non-local ones.
 236 -- A separate function (importsFromLocalDecls) reports duplicate top level
 237 -- decls, so here it's safe just to choose an arbitrary one.
 238
 239 -- There should never be a qualified name in a binding position in Haskell,
 240 -- but there can be if we have read in an external-Core file.
 241 -- The Haskell parser checks for the illegal qualified name in Haskell
 242 -- source files, so we don't need to do so here.
 243
 244   = getModeRn                   `thenM` \ mode ->
 245     case mode of
 246         InterfaceMode mod ->
 247             getSrcLocM          `thenM` \ loc ->
 248             newTopBinder mod rdr_name loc
 249
 250         other -> lookupTopSrcBndr rdr_name
 251
 252 lookupTopSrcBndr :: RdrName -> TcRn m Name
 253 lookupTopSrcBndr rdr_name
 254   = lookupTopSrcBndr_maybe rdr_name     `thenM` \ maybe_name ->
 255     case maybe_name of
 256         Just name -> returnM name
 257         Nothing   -> unboundName rdr_name
 258
 259
 260 lookupTopSrcBndr_maybe :: RdrName -> TcRn m (Maybe Name)
 261 -- Look up a source-code binder
 262
 263 -- Ignores imported names; for example, this is OK:
 264 --      import Foo( f )
 265 --      infix 9 f       -- The 'f' here does not need to be qualified
 266 --      f x = x         -- Nor here, of course
 267
 268 lookupTopSrcBndr_maybe rdr_name
 269   | Just name <- isExact_maybe rdr_name
 270         -- This is here just to catch the PrelBase defn of (say) [] and similar
 271         -- The parser reads the special syntax and returns an Exact RdrName
 272         -- But the global_env contains only Qual RdrNames, so we won't
 273         -- find it there; instead just get the name via the Orig route
 274         --
 275         -- We are at a binding site for the name, so check first that it
 276         -- the current module is the correct one; otherwise GHC can get
 277         -- very confused indeed.  This test rejects code like
 278         --      data T = (,) Int Int
 279         -- unless we are in GHC.Tup
 280   = getModule                           `thenM` \ mod ->
 281     checkErr (moduleName mod == moduleName (nameModule name))
 282              (badOrigBinding rdr_name)  `thenM_`
 283     returnM (Just name)
 284
 285   | otherwise
 286   = getGlobalRdrEnv                     `thenM` \ global_env ->
 287     case lookupRdrEnv global_env rdr_name of
 288           Nothing   -> returnM Nothing
 289           Just gres -> case [gre_name gre | gre <- gres, isLocalGRE gre] of
 290                          []     -> returnM Nothing
 291                          (n:ns) -> returnM (Just n)
 292
 293
 294 -- lookupSigOccRn is used for type signatures and pragmas
 295 -- Is this valid?
 296 --   module A
 297 --      import M( f )
 298 --      f :: Int -> Int
 299 --      f x = x
 300 -- It's clear that the 'f' in the signature must refer to A.f
 301 -- The Haskell98 report does not stipulate this, but it will!
 302 -- So we must treat the 'f' in the signature in the same way
 303 -- as the binding occurrence of 'f', using lookupBndrRn
 304 lookupSigOccRn :: RdrName -> RnM Name
 305 lookupSigOccRn = lookupBndrRn
 306
 307 -- lookupInstDeclBndr is used for the binders in an
 308 -- instance declaration.   Here we use the class name to
 309 -- disambiguate.
 310
 311 lookupInstDeclBndr :: Name -> RdrName -> RnM Name
 312         -- We use the selector name as the binder
 313 lookupInstDeclBndr cls_name rdr_name
 314   | isUnqual rdr_name
 315   =     -- Find all the things the class op name maps to
 316         -- and pick the one with the right parent name
 317     getGblEnv                           `thenM` \ gbl_env ->
 318     let
 319         avail_env = imp_env (tcg_imports gbl_env)
 320         occ       = rdrNameOcc rdr_name
 321     in
 322     case lookupAvailEnv_maybe avail_env cls_name of
 323         Nothing ->
 324             -- If the class itself isn't in scope, then cls_name will
 325             -- be unboundName, and there'll already be an error for
 326             -- that in the error list.  Example:
 327             -- e.g.   import Prelude hiding( Ord )
 328             --      instance Ord T where ...
 329             -- The program is wrong, but that should not cause a crash.
 330                 returnM (mkUnboundName rdr_name)
 331
 332         Just (AvailTC _ ns) -> case [n | n <- ns, nameOccName n == occ] of
 333                                 (n:ns)-> ASSERT( null ns ) returnM n
 334                                 []    -> unboundName rdr_name
 335
 336         other               -> pprPanic "lookupInstDeclBndr" (ppr cls_name)
 337
 338
 339   | otherwise           -- Occurs in derived instances, where we just
 340                         -- refer directly to the right method, and avail_env
 341                         -- isn't available
 342   = ASSERT2( not (isQual rdr_name), ppr rdr_name )
 343           -- NB: qualified names are rejected by the parser
 344     lookupOrigName rdr_name
 345
 346
 347 lookupSysBndr :: RdrName -> RnM Name
 348 -- Used for the 'system binders' in a data type or class declaration
 349 -- Do *not* look up in the RdrEnv; these system binders are never in scope
 350 -- Instead, get the module from the monad... but remember that
 351 -- where the module is depends on whether we are renaming source or
 352 -- interface file stuff
 353 lookupSysBndr rdr_name
 354   = getSrcLocM          `thenM` \ loc ->
 355     getModeRn           `thenM` \ mode ->
 356     case mode of
 357         InterfaceMode mod -> newTopBinder mod rdr_name loc
 358         other             -> getModule  `thenM` \ mod ->
 359                              newTopBinder mod rdr_name loc
 360
 361 -- lookupOccRn looks up an occurrence of a RdrName
 362 lookupOccRn :: RdrName -> RnM Name
 363 lookupOccRn rdr_name
 364   = getLocalRdrEnv                      `thenM` \ local_env ->
 365     case lookupRdrEnv local_env rdr_name of
 366           Just name -> returnM name
 367           Nothing   -> lookupGlobalOccRn rdr_name
 368
 369 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
 370 -- environment.  It's used only for
 371 --      record field names
 372 --      class op names in class and instance decls
 373
 374 lookupGlobalOccRn rdr_name
 375   = getModeRn           `thenM` \ mode ->
 376     case mode of
 377         InterfaceMode mod -> lookupIfaceName mod rdr_name
 378         SourceMode        -> lookupSrcName       rdr_name
 379
 380         CmdLineMode
 381          | not (isQual rdr_name) ->
 382                 lookupSrcName rdr_name
 383
 384                 -- We allow qualified names on the command line to refer to
 385                 -- *any* name exported by any module in scope, just as if
 386                 -- there was an "import qualified M" declaration for every
 387                 -- module.
 388                 --
 389                 -- First look up the name in the normal environment.  If
 390                 -- it isn't there, we manufacture a new occurrence of an
 391                 -- original name.
 392          | otherwise ->
 393                 lookupSrcName_maybe rdr_name    `thenM` \ mb_name ->
 394                 case mb_name of
 395                   Just name -> returnM name
 396                   Nothing   -> lookupQualifiedName rdr_name
 397
 398 -- A qualified name on the command line can refer to any module at all: we
 399 -- try to load the interface if we don't already have it.
 400 lookupQualifiedName :: RdrName -> TcRn m Name
 401 lookupQualifiedName rdr_name
 402  = let
 403        mod = rdrNameModule rdr_name
 404        occ = rdrNameOcc rdr_name
 405    in
 406    loadInterface (ppr rdr_name) mod (ImportByUser False) `thenM` \ iface ->
 407    case  [ name | (_,avails) <- mi_exports iface,
 408            avail             <- avails,
 409            name              <- availNames avail,
 410            nameOccName name == occ ] of
 411       (n:ns) -> ASSERT (null ns) returnM n
 412       _      -> unboundName rdr_name
 413
 414 lookupSrcName :: RdrName -> TcRn m Name
 415 lookupSrcName rdr_name
 416   = lookupSrcName_maybe rdr_name        `thenM` \ mb_name ->
 417     case mb_name of
 418         Nothing   -> unboundName rdr_name
 419         Just name -> returnM name
 420
 421 lookupSrcName_maybe :: RdrName -> TcRn m (Maybe Name)
 422 lookupSrcName_maybe rdr_name
 423   | Just name <- isExact_maybe rdr_name -- Can occur in source code too
 424   = returnM (Just name)
 425
 426   | isOrig rdr_name                     -- An original name
 427   = newGlobalNameFromRdrName rdr_name   `thenM` \ name ->
 428     returnM (Just name)
 429
 430   | otherwise
 431   = lookupGRE rdr_name  `thenM` \ mb_gre ->
 432     case mb_gre of
 433         Nothing  -> returnM Nothing
 434         Just gre -> returnM (Just (gre_name gre))
 435
 436 lookupGRE :: RdrName -> TcRn m (Maybe GlobalRdrElt)
 437 lookupGRE rdr_name
 438   = getGlobalRdrEnv                     `thenM` \ global_env ->
 439     case lookupRdrEnv global_env rdr_name of
 440         Just [gre] -> case gre_deprec gre of
 441                         Nothing -> returnM (Just gre)
 442                         Just _  -> warnDeprec gre       `thenM_`
 443                                    returnM (Just gre)
 444         Just stuff@(gre : _) -> addNameClashErrRn rdr_name stuff        `thenM_`
 445                                 returnM (Just gre)
 446         Nothing              -> return Nothing
 447
 448 lookupIfaceName :: Module -> RdrName -> TcRn m Name
 449         -- An Unqual is allowed; interface files contain
 450         -- unqualified names for locally-defined things, such as
 451         -- constructors of a data type.
 452 lookupIfaceName mod rdr_name
 453   | isUnqual rdr_name = newGlobalName mod (rdrNameOcc rdr_name) importedSrcLoc
 454   | otherwise         = lookupOrigName rdr_name
 455
 456 lookupOrigName :: RdrName -> TcRn m Name
 457         -- Just for original or exact names
 458 lookupOrigName rdr_name
 459   | Just n <- isExact_maybe rdr_name
 460         -- This happens in derived code, which we
 461         -- rename in InterfaceMode
 462   = returnM n
 463
 464   | otherwise   -- Usually Orig, but can be a Qual when
 465                 -- we are reading a .hi-boot file
 466   = newGlobalNameFromRdrName rdr_name
 467
 468
 469 dataTcOccs :: RdrName -> [RdrName]
 470 -- If the input is a data constructor, return both it and a type
 471 -- constructor.  This is useful when we aren't sure which we are
 472 -- looking at
 473 dataTcOccs rdr_name
 474   | isDataOcc occ = [rdr_name, rdr_name_tc]
 475   | otherwise     = [rdr_name]
 476   where
 477     occ         = rdrNameOcc rdr_name
 478     rdr_name_tc = setRdrNameSpace rdr_name tcName
 479 \end{code}
 480
 481 \begin{code}
 482 unboundName rdr_name = addErr (unknownNameErr rdr_name) `thenM_`
 483                        returnM (mkUnboundName rdr_name)
 484 \end{code}
 485
 486 %*********************************************************
 487 %*                                                      *
 488                 Fixities
 489 %*                                                      *
 490 %*********************************************************
 491
 492 \begin{code}
 493 --------------------------------
 494 bindLocalFixities :: [RdrNameFixitySig] -> RnM a -> RnM a
 495 -- Used for nested fixity decls
 496 -- No need to worry about type constructors here,
 497 -- Should check for duplicates but we don't
 498 bindLocalFixities fixes thing_inside
 499   | null fixes = thing_inside
 500   | otherwise  = mappM rn_sig fixes     `thenM` \ new_bit ->
 501                  extendFixityEnv new_bit thing_inside
 502   where
 503     rn_sig (FixitySig v fix src_loc)
 504         = addSrcLoc src_loc $
 505           lookupSigOccRn v              `thenM` \ new_v ->
 506           returnM (new_v, FixitySig new_v fix src_loc)
 507 \end{code}
 508
 509 --------------------------------
 510 lookupFixity is a bit strange.
 511
 512 * Nested local fixity decls are put in the local fixity env, which we
 513   find with getFixtyEnv
 514
 515 * Imported fixities are found in the HIT or PIT
 516
 517 * Top-level fixity decls in this module may be for Names that are
 518     either  Global         (constructors, class operations)
 519     or      Local/Exported (everything else)
 520   (See notes with RnNames.getLocalDeclBinders for why we have this split.)
 521   We put them all in the local fixity environment
 522
 523 \begin{code}
 524 lookupFixityRn :: Name -> RnM Fixity
 525 lookupFixityRn name
 526   = getModule                           `thenM` \ this_mod ->
 527     if nameIsLocalOrFrom this_mod name
 528     then        -- It's defined in this module
 529         getFixityEnv            `thenM` \ local_fix_env ->
 530         returnM (lookupFixity local_fix_env name)
 531
 532     else        -- It's imported
 533       -- For imported names, we have to get their fixities by doing a
 534       -- loadHomeInterface, and consulting the Ifaces that comes back
 535       -- from that, because the interface file for the Name might not
 536       -- have been loaded yet.  Why not?  Suppose you import module A,
 537       -- which exports a function 'f', thus;
 538       --        module CurrentModule where
 539       --          import A( f )
 540       --        module A( f ) where
 541       --          import B( f )
 542       -- Then B isn't loaded right away (after all, it's possible that
 543       -- nothing from B will be used).  When we come across a use of
 544       -- 'f', we need to know its fixity, and it's then, and only
 545       -- then, that we load B.hi.  That is what's happening here.
 546         loadInterface doc name_mod ImportBySystem       `thenM` \ iface ->
 547         returnM (lookupFixity (mi_fixities iface) name)
 548   where
 549     doc      = ptext SLIT("Checking fixity for") <+> ppr name
 550     name_mod = moduleName (nameModule name)
 551 \end{code}
 552
 553
 554 %*********************************************************
 555 %*                                                      *
 556 \subsection{Implicit free vars and sugar names}
 557 %*                                                      *
 558 %*********************************************************
 559
 560 @getXImplicitFVs@ forces the renamer to slurp in some things which aren't
 561 mentioned explicitly, but which might be needed by the type checker.
 562
 563 \begin{code}
 564 implicitStmtFVs source_fvs      -- Compiling a statement
 565   = stmt_fvs `plusFV` implicitModuleFVs source_fvs
 566   where
 567     stmt_fvs = mkFVs [printName, bindIOName, thenIOName, returnIOName, failIOName]
 568                 -- These are all needed implicitly when compiling a statement
 569                 -- See TcModule.tc_stmts
 570
 571 implicitModuleFVs source_fvs
 572   = mkTemplateHaskellFVs source_fvs     `plusFV`
 573     namesNeededForFlattening            `plusFV`
 574     ubiquitousNames
 575
 576
 577 thProxyName :: NameSet
 578 mkTemplateHaskellFVs :: NameSet -> NameSet
 579         -- This is a bit of a hack.  When we see the Template-Haskell construct
 580         --      [| expr |]
 581         -- we are going to need lots of the ``smart constructors'' defined in
 582         -- the main Template Haskell data type module.  Rather than treat them
 583         -- all as free vars at every occurrence site, we just make the Q type
 584         -- consructor a free var.... and then use that here to haul in the others
 585
 586 #ifdef GHCI
 587 --------------- Template Haskell enabled --------------
 588 thProxyName = unitFV qTyConName
 589
 590 mkTemplateHaskellFVs source_fvs
 591   | qTyConName `elemNameSet` source_fvs = templateHaskellNames
 592   | otherwise                           = emptyFVs
 593
 594 #else
 595 --------------- Template Haskell disabled --------------
 596
 597 thProxyName                     = emptyFVs
 598 mkTemplateHaskellFVs source_fvs = emptyFVs
 599 #endif
 600 --------------------------------------------------------
 601
 602 -- ubiquitous_names are loaded regardless, because
 603 -- they are needed in virtually every program
 604 ubiquitousNames
 605   = mkFVs [unpackCStringName, unpackCStringFoldrName,
 606            unpackCStringUtf8Name, eqStringName,
 607                 -- Virtually every program has error messages in it somewhere
 608            getName unitTyCon, funTyConName, boolTyConName, intTyConName]
 609                 -- Add occurrences for very frequently used types.
 610                 --       (e.g. we don't want to be bothered with making
 611                 --        funTyCon a free var at every function application!)
 612 \end{code}
 613
 614 %************************************************************************
 615 %*                                                                      *
 616 \subsection{Re-bindable desugaring names}
 617 %*                                                                      *
 618 %************************************************************************
 619
 620 Haskell 98 says that when you say "3" you get the "fromInteger" from the
 621 Standard Prelude, regardless of what is in scope.   However, to experiment
 622 with having a language that is less coupled to the standard prelude, we're
 623 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
 624 happens to be in scope.  Then you can
 625         import Prelude ()
 626         import MyPrelude as Prelude
 627 to get the desired effect.
 628
 629 At the moment this just happens for
 630   * fromInteger, fromRational on literals (in expressions and patterns)
 631   * negate (in expressions)
 632   * minus  (arising from n+k patterns)
 633   * "do" notation
 634
 635 We store the relevant Name in the HsSyn tree, in
 636   * HsIntegral/HsFractional
 637   * NegApp
 638   * NPlusKPatIn
 639   * HsDo
 640 respectively.  Initially, we just store the "standard" name (PrelNames.fromIntegralName,
 641 fromRationalName etc), but the renamer changes this to the appropriate user
 642 name if Opt_NoImplicitPrelude is on.  That is what lookupSyntaxName does.
 643
 644 We treat the orignal (standard) names as free-vars too, because the type checker
 645 checks the type of the user thing against the type of the standard thing.
 646
 647 \begin{code}
 648 lookupSyntaxName :: Name                        -- The standard name
 649                  -> RnM (Name, FreeVars)        -- Possibly a non-standard name
 650 lookupSyntaxName std_name
 651   = doptM Opt_NoImplicitPrelude         `thenM` \ no_prelude ->
 652     if not no_prelude then normal_case
 653     else
 654     getModeRn                           `thenM` \ mode ->
 655     if isInterfaceMode mode then normal_case
 656         -- Happens for 'derived' code where we don't want to rebind
 657     else
 658         -- Get the similarly named thing from the local environment
 659     lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
 660     returnM (usr_name, mkFVs [usr_name, std_name])
 661   where
 662     normal_case = returnM (std_name, unitFV std_name)
 663
 664 lookupSyntaxNames :: [Name]                             -- Standard names
 665                   -> RnM (ReboundNames Name, FreeVars)  -- See comments with HsExpr.ReboundNames
 666 lookupSyntaxNames std_names
 667   = doptM Opt_NoImplicitPrelude         `thenM` \ no_prelude ->
 668     if not no_prelude then normal_case
 669     else
 670     getModeRn                           `thenM` \ mode ->
 671     if isInterfaceMode mode then normal_case
 672     else
 673         -- Get the similarly named thing from the local environment
 674     mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names   `thenM` \ usr_names ->
 675
 676     returnM (std_names `zip` map HsVar usr_names, mkFVs std_names `plusFV` mkFVs usr_names)
 677   where
 678     normal_case = returnM (std_names `zip` map HsVar std_names, mkFVs std_names)
 679 \end{code}
 680
 681
 682 %*********************************************************
 683 %*                                                      *
 684 \subsection{Binding}
 685 %*                                                      *
 686 %*********************************************************
 687
 688 \begin{code}
 689 newLocalsRn :: [(RdrName,SrcLoc)]
 690             -> RnM [Name]
 691 newLocalsRn rdr_names_w_loc
 692  =  newUniqueSupply             `thenM` \ us ->
 693     let
 694         uniqs      = uniqsFromSupply us
 695         names      = [ mkInternalName uniq (rdrNameOcc rdr_name) loc
 696                      | ((rdr_name,loc), uniq) <- rdr_names_w_loc `zip` uniqs
 697                      ]
 698     in
 699     returnM names
 700
 701
 702 bindLocatedLocalsRn :: SDoc     -- Documentation string for error message
 703                     -> [(RdrName,SrcLoc)]
 704                     -> ([Name] -> RnM a)
 705                     -> RnM a
 706 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
 707   = getModeRn                   `thenM` \ mode ->
 708     getLocalRdrEnv              `thenM` \ local_env ->
 709     getGlobalRdrEnv             `thenM` \ global_env ->
 710
 711         -- Check for duplicate names
 712     checkDupOrQualNames doc_str rdr_names_w_loc `thenM_`
 713
 714         -- Warn about shadowing, but only in source modules
 715     let
 716       check_shadow (rdr_name,loc)
 717         |  rdr_name `elemRdrEnv` local_env
 718         || rdr_name `elemRdrEnv` global_env
 719         = addSrcLoc loc $ addWarn (shadowedNameWarn rdr_name)
 720         | otherwise
 721         = returnM ()
 722     in
 723
 724     (case mode of
 725         SourceMode -> ifOptM Opt_WarnNameShadowing      $
 726                       mappM_ check_shadow rdr_names_w_loc
 727         other      -> returnM ()
 728     )                                   `thenM_`
 729
 730     newLocalsRn rdr_names_w_loc         `thenM` \ names ->
 731     let
 732         new_local_env = addListToRdrEnv local_env (map fst rdr_names_w_loc `zip` names)
 733     in
 734     setLocalRdrEnv new_local_env (enclosed_scope names)
 735
 736 bindCoreLocalRn :: RdrName -> (Name -> RnM a) -> RnM a
 737   -- A specialised variant when renaming stuff from interface
 738   -- files (of which there is a lot)
 739   --    * one at a time
 740   --    * no checks for shadowing
 741   --    * always imported
 742   --    * deal with free vars
 743 bindCoreLocalRn rdr_name enclosed_scope
 744   = getSrcLocM          `thenM` \ loc ->
 745     getLocalRdrEnv              `thenM` \ name_env ->
 746     newUnique                   `thenM` \ uniq ->
 747     let
 748         name         = mkInternalName uniq (rdrNameOcc rdr_name) loc
 749         new_name_env = extendRdrEnv name_env rdr_name name
 750     in
 751     setLocalRdrEnv new_name_env (enclosed_scope name)
 752
 753 bindCoreLocalsRn []     thing_inside = thing_inside []
 754 bindCoreLocalsRn (b:bs) thing_inside = bindCoreLocalRn b        $ \ name' ->
 755                                        bindCoreLocalsRn bs      $ \ names' ->
 756                                        thing_inside (name':names')
 757
 758 bindLocalNames names enclosed_scope
 759   = getLocalRdrEnv              `thenM` \ name_env ->
 760     setLocalRdrEnv (extendLocalRdrEnv name_env names)
 761                     enclosed_scope
 762
 763 bindLocalNamesFV names enclosed_scope
 764   = bindLocalNames names $
 765     enclosed_scope `thenM` \ (thing, fvs) ->
 766     returnM (thing, delListFromNameSet fvs names)
 767
 768
 769 -------------------------------------
 770 bindLocalRn doc rdr_name enclosed_scope
 771   = getSrcLocM                          `thenM` \ loc ->
 772     bindLocatedLocalsRn doc [(rdr_name,loc)]    $ \ (n:ns) ->
 773     ASSERT( null ns )
 774     enclosed_scope n
 775
 776 bindLocalsRn doc rdr_names enclosed_scope
 777   = getSrcLocM          `thenM` \ loc ->
 778     bindLocatedLocalsRn doc
 779                         (rdr_names `zip` repeat loc)
 780                         enclosed_scope
 781
 782         -- binLocalsFVRn is the same as bindLocalsRn
 783         -- except that it deals with free vars
 784 bindLocalsFV doc rdr_names enclosed_scope
 785   = bindLocalsRn doc rdr_names          $ \ names ->
 786     enclosed_scope names                `thenM` \ (thing, fvs) ->
 787     returnM (thing, delListFromNameSet fvs names)
 788
 789 -------------------------------------
 790 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
 791         -- This tiresome function is used only in rnSourceDecl on InstDecl
 792 extendTyVarEnvFVRn tyvars enclosed_scope
 793   = bindLocalNames tyvars enclosed_scope        `thenM` \ (thing, fvs) ->
 794     returnM (thing, delListFromNameSet fvs tyvars)
 795
 796 bindTyVarsRn :: SDoc -> [HsTyVarBndr RdrName]
 797               -> ([HsTyVarBndr Name] -> RnM a)
 798               -> RnM a
 799 bindTyVarsRn doc_str tyvar_names enclosed_scope
 800   = getSrcLocM                                  `thenM` \ loc ->
 801     let
 802         located_tyvars = [(hsTyVarName tv, loc) | tv <- tyvar_names]
 803     in
 804     bindLocatedLocalsRn doc_str located_tyvars  $ \ names ->
 805     enclosed_scope (zipWith replaceTyVarName tyvar_names names)
 806
 807 bindPatSigTyVars :: [RdrNameHsType] -> ([Name] -> RnM a) -> RnM a
 808   -- Find the type variables in the pattern type
 809   -- signatures that must be brought into scope
 810
 811 bindPatSigTyVars tys thing_inside
 812   = getLocalRdrEnv              `thenM` \ name_env ->
 813     getSrcLocM                  `thenM` \ loc ->
 814     let
 815         forall_tyvars  = nub [ tv | ty <- tys,
 816                                     tv <- extractHsTyRdrTyVars ty,
 817                                     not (tv `elemFM` name_env)
 818                          ]
 819                 -- The 'nub' is important.  For example:
 820                 --      f (x :: t) (y :: t) = ....
 821                 -- We don't want to complain about binding t twice!
 822
 823         located_tyvars = [(tv, loc) | tv <- forall_tyvars]
 824         doc_sig        = text "In a pattern type-signature"
 825     in
 826     bindLocatedLocalsRn doc_sig located_tyvars thing_inside
 827
 828 bindPatSigTyVarsFV :: [RdrNameHsType]
 829                    -> RnM (a, FreeVars)
 830                    -> RnM (a, FreeVars)
 831 bindPatSigTyVarsFV tys thing_inside
 832   = bindPatSigTyVars tys        $ \ tvs ->
 833     thing_inside                `thenM` \ (result,fvs) ->
 834     returnM (result, fvs `delListFromNameSet` tvs)
 835
 836 -------------------------------------
 837 checkDupOrQualNames, checkDupNames :: SDoc
 838                                    -> [(RdrName, SrcLoc)]
 839                                    -> TcRn m ()
 840         -- Works in any variant of the renamer monad
 841
 842 checkDupOrQualNames doc_str rdr_names_w_loc
 843   =     -- Qualified names in patterns are now rejected by the parser
 844         -- but I'm not 100% certain that it finds all cases, so I've left
 845         -- this check in for now.  Should go eventually.
 846         --      Hmm.  Sooner rather than later.. data type decls
 847 --     mappM_ (qualNameErr doc_str) quals       `thenM_`
 848     checkDupNames doc_str rdr_names_w_loc
 849   where
 850     quals = filter (isQual . fst) rdr_names_w_loc
 851
 852 checkDupNames doc_str rdr_names_w_loc
 853   =     -- Check for duplicated names in a binding group
 854     mappM_ (dupNamesErr doc_str) dups
 855   where
 856     (_, dups) = removeDups (\(n1,l1) (n2,l2) -> n1 `compare` n2) rdr_names_w_loc
 857 \end{code}
 858
 859
 860 %************************************************************************
 861 %*                                                                      *
 862 \subsection{GlobalRdrEnv}
 863 %*                                                                      *
 864 %************************************************************************
 865
 866 \begin{code}
 867 mkGlobalRdrEnv :: ModuleName            -- Imported module (after doing the "as M" name change)
 868                -> Bool                  -- True <=> want unqualified import
 869                -> (Name -> Provenance)
 870                -> Avails                -- Whats imported
 871                -> Deprecations
 872                -> GlobalRdrEnv
 873
 874 mkGlobalRdrEnv this_mod unqual_imp mk_provenance avails deprecs
 875   = gbl_env2
 876   where
 877         -- Make the name environment.  We're talking about a
 878         -- single module here, so there must be no name clashes.
 879         -- In practice there only ever will be if it's the module
 880         -- being compiled.
 881
 882         -- Add qualified names for the things that are available
 883         -- (Qualified names are always imported)
 884     gbl_env1 = foldl add_avail emptyRdrEnv avails
 885
 886         -- Add unqualified names
 887     gbl_env2 | unqual_imp = foldl add_unqual gbl_env1 (rdrEnvToList gbl_env1)
 888              | otherwise  = gbl_env1
 889
 890     add_unqual env (qual_name, elts)
 891         = foldl add_one env elts
 892         where
 893           add_one env elt = addOneToGlobalRdrEnv env unqual_name elt
 894           unqual_name     = unqualifyRdrName qual_name
 895         -- The qualified import should only have added one
 896         -- binding for each qualified name!  But if there's an error in
 897         -- the module (multiple bindings for the same name) we may get
 898         -- duplicates.  So the simple thing is to do the fold.
 899
 900     add_avail :: GlobalRdrEnv -> AvailInfo -> GlobalRdrEnv
 901     add_avail env avail = foldl (add_name (availName avail)) env (availNames avail)
 902
 903     add_name parent env name    -- Add qualified name only
 904         = addOneToGlobalRdrEnv env (mkRdrQual this_mod occ) elt
 905         where
 906           occ  = nameOccName name
 907           elt  = GRE {gre_name   = name,
 908                       gre_parent = if name == parent
 909                                    then Nothing
 910                                    else Just parent,
 911                       gre_prov   = mk_provenance name,
 912                       gre_deprec = lookupDeprec deprecs name}
 913 \end{code}
 914
 915 \begin{code}
 916 plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
 917 plusGlobalRdrEnv env1 env2 = plusFM_C combine_globals env1 env2
 918
 919 addOneToGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> GlobalRdrElt -> GlobalRdrEnv
 920 addOneToGlobalRdrEnv env rdr_name name = addToFM_C combine_globals env rdr_name [name]
 921
 922 delOneFromGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> GlobalRdrEnv
 923 delOneFromGlobalRdrEnv env rdr_name = delFromFM env rdr_name
 924
 925 combine_globals :: [GlobalRdrElt]       -- Old
 926                 -> [GlobalRdrElt]       -- New
 927                 -> [GlobalRdrElt]
 928 combine_globals ns_old ns_new   -- ns_new is often short
 929   = foldr add ns_old ns_new
 930   where
 931     add n ns | any (is_duplicate n) ns_old = map (choose n) ns  -- Eliminate duplicates
 932              | otherwise                   = n:ns
 933
 934     choose n m | n `beats` m = n
 935                | otherwise   = m
 936
 937     g1 `beats` g2 = gre_name g1 == gre_name g2 &&
 938                     gre_prov g1 `hasBetterProv` gre_prov g2
 939
 940     is_duplicate :: GlobalRdrElt -> GlobalRdrElt -> Bool
 941     is_duplicate g1 g2 | isLocalGRE g1 && isLocalGRE g2 = False
 942     is_duplicate g1 g2 = gre_name g1 == gre_name g2
 943 \end{code}
 944
 945 We treat two bindings of a locally-defined name as a duplicate,
 946 because they might be two separate, local defns and we want to report
 947 and error for that, {\em not} eliminate a duplicate.
 948
 949 On the other hand, if you import the same name from two different
 950 import statements, we {\em do} want to eliminate the duplicate, not report
 951 an error.
 952
 953 If a module imports itself then there might be a local defn and an imported
 954 defn of the same name; in this case the names will compare as equal, but
 955 will still have different provenances.
 956
 957
 958 %************************************************************************
 959 %*                                                                      *
 960 \subsection{Free variable manipulation}
 961 %*                                                                      *
 962 %************************************************************************
 963
 964 \begin{code}
 965 -- A useful utility
 966 mapFvRn f xs = mappM f xs       `thenM` \ stuff ->
 967                let
 968                   (ys, fvs_s) = unzip stuff
 969                in
 970                returnM (ys, plusFVs fvs_s)
 971 \end{code}
 972
 973
 974 %************************************************************************
 975 %*                                                                      *
 976 \subsection{Envt utility functions}
 977 %*                                                                      *
 978 %************************************************************************
 979
 980 \begin{code}
 981 warnUnusedModules :: [ModuleName] -> TcRn m ()
 982 warnUnusedModules mods
 983   = ifOptM Opt_WarnUnusedImports (mappM_ (addWarn . unused_mod) mods)
 984   where
 985     unused_mod m = vcat [ptext SLIT("Module") <+> quotes (ppr m) <+>
 986                            text "is imported, but nothing from it is used",
 987                          parens (ptext SLIT("except perhaps instances visible in") <+>
 988                                    quotes (ppr m))]
 989
 990 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> TcRn m ()
 991 warnUnusedImports gres  = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
 992 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds   (warnUnusedGREs gres)
 993
 994 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> TcRn m ()
 995 warnUnusedLocalBinds names = ifOptM Opt_WarnUnusedBinds   (warnUnusedLocals names)
 996 warnUnusedMatches    names = ifOptM Opt_WarnUnusedMatches (warnUnusedLocals names)
 997
 998 -------------------------
 999 --      Helpers
1000 warnUnusedGREs   gres  = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1001 warnUnusedLocals names = warnUnusedBinds [(n,LocalDef) | n<-names]
1002
1003 warnUnusedBinds :: [(Name,Provenance)] -> TcRn m ()
1004 warnUnusedBinds names
1005   = mappM_ warnUnusedGroup groups
1006   where
1007         -- Group by provenance
1008    groups = equivClasses cmp (filter reportable names)
1009    (_,prov1) `cmp` (_,prov2) = prov1 `compare` prov2
1010
1011    reportable (name,_) = reportIfUnused (nameOccName name)
1012
1013
1014 -------------------------
1015
1016 warnUnusedGroup :: [(Name,Provenance)] -> TcRn m ()
1017 warnUnusedGroup names
1018   = addSrcLoc def_loc   $
1019     addWarn             $
1020     sep [msg <> colon, nest 4 (fsep (punctuate comma (map (ppr.fst) names)))]
1021   where
1022     (name1, prov1) = head names
1023     loc1           = nameSrcLoc name1
1024     (def_loc, msg) = case prov1 of
1025                         LocalDef                           -> (loc1, unused_msg)
1026                         NonLocalDef (UserImport mod loc _) -> (loc,  imp_from mod)
1027
1028     unused_msg   = text "Defined but not used"
1029     imp_from mod = text "Imported from" <+> quotes (ppr mod) <+> text "but not used"
1030 \end{code}
1031
1032 \begin{code}
1033 addNameClashErrRn rdr_name (np1:nps)
1034   = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
1035                   ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
1036   where
1037     msg1 = ptext  SLIT("either") <+> mk_ref np1
1038     msgs = [ptext SLIT("    or") <+> mk_ref np | np <- nps]
1039     mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1040
1041 shadowedNameWarn shadow
1042   = hsep [ptext SLIT("This binding for"),
1043                quotes (ppr shadow),
1044                ptext SLIT("shadows an existing binding")]
1045
1046 unknownNameErr name
1047   = sep [text flavour, ptext SLIT("not in scope:"), quotes (ppr name)]
1048   where
1049     flavour = occNameFlavour (rdrNameOcc name)
1050
1051 badOrigBinding name
1052   = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1053         -- The rdrNameOcc is because we don't want to print Prelude.(,)
1054
1055 qualNameErr descriptor (name,loc)
1056   = addSrcLoc loc $
1057     addErr (vcat [ ptext SLIT("Invalid use of qualified name") <+> quotes (ppr name),
1058                      descriptor])
1059
1060 dupNamesErr descriptor ((name,loc) : dup_things)
1061   = addSrcLoc loc $
1062     addErr ((ptext SLIT("Conflicting definitions for") <+> quotes (ppr name))
1063               $$
1064               descriptor)
1065
1066 noIfaceErr dflags mod_name boot_file files
1067   = ptext SLIT("Could not find interface file for") <+> quotes (ppr mod_name)
1068     $$ extra
1069   where
1070    extra
1071     | verbosity dflags < 3 =
1072         text "(use -v to see a list of the files searched for)"
1073     | otherwise =
1074         hang (ptext SLIT("locations searched:")) 4 (vcat (map text files))
1075
1076 warnDeprec :: GlobalRdrElt -> TcRn m ()
1077 warnDeprec (GRE {gre_name = name, gre_deprec = Just txt})
1078   = ifOptM Opt_WarnDeprecations $
1079     addWarn (sep [ text (occNameFlavour (nameOccName name)) <+>
1080                      quotes (ppr name) <+> text "is deprecated:",
1081                      nest 4 (ppr txt) ])
1082 \end{code}
1083