compiler/rename/RnEnv.lhs

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