2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
4 \section[RnEnv]{Environment manipulation for the renamer monad}
8 newTopSrcBinder, lookupFamInstDeclBndr,
9 lookupLocatedBndrRn, lookupBndrRn, lookupBndrRn_maybe,
10 lookupLocatedTopBndrRn, lookupTopBndrRn,
11 lookupLocatedOccRn, lookupOccRn,
12 lookupLocatedGlobalOccRn, lookupGlobalOccRn,
13 lookupLocalDataTcNames, lookupSrcOcc_maybe,
14 lookupFixityRn, lookupTyFixityRn, lookupLocatedSigOccRn,
15 lookupInstDeclBndr, lookupRecordBndr, lookupConstructorFields,
16 lookupSyntaxName, lookupSyntaxTable, lookupImportedName,
17 lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
20 newLocalsRn, newIPNameRn,
21 bindLocalNames, bindLocalNamesFV,
22 MiniFixityEnv, emptyFsEnv, extendFsEnv, lookupFsEnv,
23 bindLocalNamesFV_WithFixities,
24 bindLocatedLocalsFV, bindLocatedLocalsRn,
25 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
26 bindTyVarsRn, extendTyVarEnvFVRn,
28 checkDupRdrNames, checkDupNames, checkShadowedNames,
29 checkDupAndShadowedRdrNames,
31 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
32 warnUnusedTopBinds, warnUnusedLocalBinds,
33 dataTcOccs, unknownNameErr
36 #include "HsVersions.h"
38 import LoadIface ( loadInterfaceForName, loadSrcInterface )
39 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
41 import RdrHsSyn ( extractHsTyRdrTyVars )
43 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity)
44 import TcEnv ( tcLookupDataCon )
46 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
47 nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
51 import DataCon ( dataConFieldLabels )
53 import Module ( Module, ModuleName )
54 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE,
55 consDataConKey, hasKey, forall_tv_RDR )
57 import BasicTypes ( IPName, mapIPName, Fixity )
62 import ListSetOps ( removeDups )
71 thenM :: Monad a => a b -> (b -> a c) -> a c
74 thenM_ :: Monad a => a b -> a c -> a c
77 returnM :: Monad m => a -> m a
80 mappM :: (Monad m) => (a -> m b) -> [a] -> m [b]
83 mappM_ :: (Monad m) => (a -> m b) -> [a] -> m ()
86 checkM :: Monad m => Bool -> m () -> m ()
90 %*********************************************************
94 %*********************************************************
97 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
98 newTopSrcBinder this_mod (L loc rdr_name)
99 | Just name <- isExact_maybe rdr_name
100 = -- This is here to catch
101 -- (a) Exact-name binders created by Template Haskell
102 -- (b) The PrelBase defn of (say) [] and similar, for which
103 -- the parser reads the special syntax and returns an Exact RdrName
104 -- We are at a binding site for the name, so check first that it
105 -- the current module is the correct one; otherwise GHC can get
106 -- very confused indeed. This test rejects code like
107 -- data T = (,) Int Int
108 -- unless we are in GHC.Tup
109 ASSERT2( isExternalName name, ppr name )
110 do { checkM (this_mod == nameModule name)
111 (addErrAt loc (badOrigBinding rdr_name))
115 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
116 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
117 (addErrAt loc (badOrigBinding rdr_name))
118 -- When reading External Core we get Orig names as binders,
119 -- but they should agree with the module gotten from the monad
121 -- We can get built-in syntax showing up here too, sadly. If you type
123 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
124 -- uses setRdrNameSpace to make it into a data constructors. At that point
125 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
126 -- Hence the badOrigBinding error message.
128 -- Except for the ":Main.main = ..." definition inserted into
129 -- the Main module; ugh!
131 -- Because of this latter case, we call newGlobalBinder with a module from
132 -- the RdrName, not from the environment. In principle, it'd be fine to
133 -- have an arbitrary mixture of external core definitions in a single module,
134 -- (apart from module-initialisation issues, perhaps).
135 ; newGlobalBinder rdr_mod rdr_occ loc }
136 --TODO, should pass the whole span
139 = do { checkM (not (isQual rdr_name))
140 (addErrAt loc (badQualBndrErr rdr_name))
141 -- Binders should not be qualified; if they are, and with a different
142 -- module name, we we get a confusing "M.T is not in scope" error later
143 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
146 %*********************************************************
148 Source code occurrences
150 %*********************************************************
152 Looking up a name in the RnEnv.
155 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
156 lookupLocatedBndrRn = wrapLocM lookupBndrRn
158 lookupBndrRn :: RdrName -> RnM Name
159 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
162 Nothing -> do traceRn $ text "lookupTopBndrRn"
165 lookupTopBndrRn :: RdrName -> RnM Name
166 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
169 Nothing -> do traceRn $ text "lookupTopBndrRn"
172 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
173 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
174 lookupBndrRn_maybe rdr_name
175 = getLocalRdrEnv `thenM` \ local_env ->
176 case lookupLocalRdrEnv local_env rdr_name of
177 Just name -> returnM (Just name)
178 Nothing -> lookupTopBndrRn_maybe rdr_name
180 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
181 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
183 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
184 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
185 -- and there may be several imported 'f's too, which must not confuse us.
186 -- For example, this is OK:
188 -- infix 9 f -- The 'f' here does not need to be qualified
189 -- f x = x -- Nor here, of course
190 -- So we have to filter out the non-local ones.
192 -- A separate function (importsFromLocalDecls) reports duplicate top level
193 -- decls, so here it's safe just to choose an arbitrary one.
195 -- There should never be a qualified name in a binding position in Haskell,
196 -- but there can be if we have read in an external-Core file.
197 -- The Haskell parser checks for the illegal qualified name in Haskell
198 -- source files, so we don't need to do so here.
200 lookupTopBndrRn_maybe rdr_name
201 | Just name <- isExact_maybe rdr_name
202 = returnM (Just name)
204 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
205 -- This deals with the case of derived bindings, where
206 -- we don't bother to call newTopSrcBinder first
207 -- We assume there is no "parent" name
208 = do { loc <- getSrcSpanM
209 ; n <- newGlobalBinder rdr_mod rdr_occ loc
213 = do { mb_gre <- lookupGreLocalRn rdr_name
215 Nothing -> returnM Nothing
216 Just gre -> returnM (Just $ gre_name gre) }
218 -- lookupLocatedSigOccRn is used for type signatures and pragmas
224 -- It's clear that the 'f' in the signature must refer to A.f
225 -- The Haskell98 report does not stipulate this, but it will!
226 -- So we must treat the 'f' in the signature in the same way
227 -- as the binding occurrence of 'f', using lookupBndrRn
229 -- However, consider this case:
233 -- We don't want to say 'f' is out of scope; instead, we want to
234 -- return the imported 'f', so that later on the reanamer will
235 -- correctly report "misplaced type sig".
236 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
237 lookupLocatedSigOccRn = wrapLocM $ \ rdr_name -> do
238 { local_env <- getLocalRdrEnv
239 ; case lookupLocalRdrEnv local_env rdr_name of {
242 { mb_gre <- lookupGreLocalRn rdr_name
244 Just gre -> return (gre_name gre)
245 Nothing -> lookupGlobalOccRn rdr_name
248 -----------------------------------------------
249 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
250 -- This is called on the method name on the left-hand side of an
251 -- instance declaration binding. eg. instance Functor T where
253 -- ^^^^ called on this
254 -- Regardless of how many unqualified fmaps are in scope, we want
255 -- the one that comes from the Functor class.
257 -- Furthermore, note that we take no account of whether the
258 -- name is only in scope qualified. I.e. even if method op is
259 -- in scope as M.op, we still allow plain 'op' on the LHS of
261 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
263 doc = ptext (sLit "method of class") <+> quotes (ppr cls)
264 is_op (GRE {gre_par = ParentIs n}) = n == cls
267 -----------------------------------------------
268 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
269 -- Used for record construction and pattern matching
270 -- When the -fdisambiguate-record-fields flag is on, take account of the
271 -- constructor name to disambiguate which field to use; it's just the
272 -- same as for instance decls
273 lookupRecordBndr Nothing rdr_name
274 = lookupLocatedGlobalOccRn rdr_name
275 lookupRecordBndr (Just (L _ data_con)) rdr_name
276 = do { flag_on <- doptM Opt_DisambiguateRecordFields
278 then lookupLocatedGlobalOccRn rdr_name
280 fields <- lookupConstructorFields data_con
281 ; let is_field gre = gre_name gre `elem` fields
282 ; lookup_located_sub_bndr is_field doc rdr_name
285 doc = ptext (sLit "field of constructor") <+> quotes (ppr data_con)
288 lookupConstructorFields :: Name -> RnM [Name]
289 -- Look up the fields of a given constructor
290 -- * For constructors from this module, use the record field env,
291 -- which is itself gathered from the (as yet un-typechecked)
294 -- * For constructors from imported modules, use the *type* environment
295 -- since imported modles are already compiled, the info is conveniently
298 lookupConstructorFields con_name
299 = do { this_mod <- getModule
300 ; if nameIsLocalOrFrom this_mod con_name then
301 do { field_env <- getRecFieldEnv
302 ; return (lookupNameEnv field_env con_name `orElse` []) }
304 do { con <- tcLookupDataCon con_name
305 ; return (dataConFieldLabels con) } }
307 -----------------------------------------------
308 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
309 -> SDoc -> Located RdrName
310 -> RnM (Located Name)
311 lookup_located_sub_bndr is_good doc rdr_name
312 = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
314 lookup_sub_bndr :: (GlobalRdrElt -> Bool) -> SDoc -> RdrName -> RnM Name
315 lookup_sub_bndr is_good doc rdr_name
316 | isUnqual rdr_name -- Find all the things the rdr-name maps to
317 = do { -- and pick the one with the right parent name
318 ; env <- getGlobalRdrEnv
319 ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
320 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
321 -- The latter does pickGREs, but we want to allow 'x'
322 -- even if only 'M.x' is in scope
323 [gre] -> return (gre_name gre)
324 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
325 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
326 ; return (mkUnboundName rdr_name) }
327 gres -> do { addNameClashErrRn rdr_name gres
328 ; return (gre_name (head gres)) }
331 | otherwise -- Occurs in derived instances, where we just
332 -- refer directly to the right method
333 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
334 -- NB: qualified names are rejected by the parser
335 lookupImportedName rdr_name
337 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
338 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
340 -- Looking up family names in type instances is a subtle affair. The family
341 -- may be imported, in which case we need to lookup the occurence of a global
342 -- name. Alternatively, the family may be in the same binding group (and in
343 -- fact in a declaration processed later), and we need to create a new top
346 -- So, also this is strictly speaking an occurence, we cannot raise an error
347 -- message yet for instances without a family declaration. This will happen
348 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
350 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
351 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
352 = do { mb_gre <- lookupGreRn_maybe rdr_name
354 Just gre -> returnM (gre_name gre) ;
355 Nothing -> newTopSrcBinder mod lrdr_name }
357 --------------------------------------------------
359 --------------------------------------------------
361 getLookupOccRn :: RnM (Name -> Maybe Name)
363 = getLocalRdrEnv `thenM` \ local_env ->
364 return (lookupLocalRdrOcc local_env . nameOccName)
366 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
367 lookupLocatedOccRn = wrapLocM lookupOccRn
369 -- lookupOccRn looks up an occurrence of a RdrName
370 lookupOccRn :: RdrName -> RnM Name
372 = getLocalRdrEnv `thenM` \ local_env ->
373 case lookupLocalRdrEnv local_env rdr_name of
374 Just name -> returnM name
375 Nothing -> lookupGlobalOccRn rdr_name
377 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
378 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
380 lookupGlobalOccRn :: RdrName -> RnM Name
381 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
382 -- environment. It's used only for
383 -- record field names
384 -- class op names in class and instance decls
386 lookupGlobalOccRn rdr_name
387 | not (isSrcRdrName rdr_name)
388 = lookupImportedName rdr_name
391 = -- First look up the name in the normal environment.
392 lookupGreRn_maybe rdr_name `thenM` \ mb_gre ->
394 Just gre -> returnM (gre_name gre) ;
397 -- We allow qualified names on the command line to refer to
398 -- *any* name exported by any module in scope, just as if
399 -- there was an "import qualified M" declaration for every
401 getModule `thenM` \ mod ->
402 if isQual rdr_name && mod == iNTERACTIVE then
403 -- This test is not expensive,
404 lookupQualifiedName rdr_name -- and only happens for failed lookups
406 traceRn $ text "lookupGlobalOccRn"
407 unboundName rdr_name }
409 lookupImportedName :: RdrName -> TcRnIf m n Name
410 -- Lookup the occurrence of an imported name
411 -- The RdrName is *always* qualified or Exact
412 -- Treat it as an original name, and conjure up the Name
413 -- Usually it's Exact or Orig, but it can be Qual if it
414 -- comes from an hi-boot file. (This minor infelicity is
415 -- just to reduce duplication in the parser.)
416 lookupImportedName rdr_name
417 | Just n <- isExact_maybe rdr_name
418 -- This happens in derived code
421 -- Always Orig, even when reading a .hi-boot file
422 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
423 = lookupOrig rdr_mod rdr_occ
426 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
428 unboundName :: RdrName -> RnM Name
430 = do { addErr (unknownNameErr rdr_name)
431 ; env <- getGlobalRdrEnv;
432 ; traceRn (vcat [unknownNameErr rdr_name,
433 ptext (sLit "Global envt is:"),
434 nest 3 (pprGlobalRdrEnv env)])
435 ; returnM (mkUnboundName rdr_name) }
437 --------------------------------------------------
438 -- Lookup in the Global RdrEnv of the module
439 --------------------------------------------------
441 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
442 -- No filter function; does not report an error on failure
443 lookupSrcOcc_maybe rdr_name
444 = do { mb_gre <- lookupGreRn_maybe rdr_name
446 Nothing -> returnM Nothing
447 Just gre -> returnM (Just (gre_name gre)) }
449 -------------------------
450 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
451 -- Just look up the RdrName in the GlobalRdrEnv
452 lookupGreRn_maybe rdr_name
453 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
455 lookupGreRn :: RdrName -> RnM GlobalRdrElt
456 -- If not found, add error message, and return a fake GRE
458 = do { mb_gre <- lookupGreRn_maybe rdr_name
460 Just gre -> return gre ;
462 { traceRn $ text "lookupGreRn"
463 ; name <- unboundName rdr_name
464 ; return (GRE { gre_name = name, gre_par = NoParent,
465 gre_prov = LocalDef }) }}}
467 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
468 -- Similar, but restricted to locally-defined things
469 lookupGreLocalRn rdr_name
470 = lookupGreRn_help rdr_name lookup_fn
472 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
474 lookupGreRn_help :: RdrName -- Only used in error message
475 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
476 -> RnM (Maybe GlobalRdrElt)
477 -- Checks for exactly one match; reports deprecations
478 -- Returns Nothing, without error, if too few
479 lookupGreRn_help rdr_name lookup
480 = do { env <- getGlobalRdrEnv
482 [] -> returnM Nothing
483 [gre] -> returnM (Just gre)
484 gres -> do { addNameClashErrRn rdr_name gres
485 ; returnM (Just (head gres)) } }
487 ------------------------------
489 ------------------------------
491 -- A qualified name on the command line can refer to any module at all: we
492 -- try to load the interface if we don't already have it.
493 lookupQualifiedName :: RdrName -> RnM Name
494 lookupQualifiedName rdr_name
495 | Just (mod,occ) <- isQual_maybe rdr_name
496 -- Note: we want to behave as we would for a source file import here,
497 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
498 = loadSrcInterface doc mod False `thenM` \ iface ->
501 (mod,avails) <- mi_exports iface,
503 name <- availNames avail,
505 ((mod,occ):ns) -> ASSERT (null ns)
507 _ -> unboundName rdr_name
510 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
512 doc = ptext (sLit "Need to find") <+> ppr rdr_name
515 %*********************************************************
519 %*********************************************************
522 --------------------------------
523 type FastStringEnv a = UniqFM a -- Keyed by FastString
526 emptyFsEnv :: FastStringEnv a
527 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
528 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
530 emptyFsEnv = emptyUFM
531 lookupFsEnv = lookupUFM
532 extendFsEnv = addToUFM
534 --------------------------------
535 type MiniFixityEnv = FastStringEnv (Located Fixity)
536 -- Mini fixity env for the names we're about
537 -- to bind, in a single binding group
539 -- It is keyed by the *FastString*, not the *OccName*, because
540 -- the single fixity decl infix 3 T
541 -- affects both the data constructor T and the type constrctor T
543 -- We keep the location so that if we find
544 -- a duplicate, we can report it sensibly
546 --------------------------------
547 -- Used for nested fixity decls to bind names along with their fixities.
548 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
549 -- Also check for unused binders
550 bindLocalNamesFV_WithFixities :: [Name]
552 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
553 bindLocalNamesFV_WithFixities names fixities thing_inside
554 = bindLocalNamesFV names $
555 extendFixityEnv boundFixities $
558 -- find the names that have fixity decls
559 boundFixities = foldr
561 -- check whether this name has a fixity decl
562 case lookupFsEnv fixities (occNameFS (nameOccName name)) of
563 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
564 Nothing -> acc) [] names
565 -- bind the names; extend the fixity env; do the thing inside
568 --------------------------------
569 lookupFixity is a bit strange.
571 * Nested local fixity decls are put in the local fixity env, which we
572 find with getFixtyEnv
574 * Imported fixities are found in the HIT or PIT
576 * Top-level fixity decls in this module may be for Names that are
577 either Global (constructors, class operations)
578 or Local/Exported (everything else)
579 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
580 We put them all in the local fixity environment
583 lookupFixityRn :: Name -> RnM Fixity
585 = getModule `thenM` \ this_mod ->
586 if nameIsLocalOrFrom this_mod name
587 then do -- It's defined in this module
588 local_fix_env <- getFixityEnv
589 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
590 vcat [ppr name, ppr local_fix_env])
591 return $ lookupFixity local_fix_env name
592 else -- It's imported
593 -- For imported names, we have to get their fixities by doing a
594 -- loadInterfaceForName, and consulting the Ifaces that comes back
595 -- from that, because the interface file for the Name might not
596 -- have been loaded yet. Why not? Suppose you import module A,
597 -- which exports a function 'f', thus;
598 -- module CurrentModule where
600 -- module A( f ) where
602 -- Then B isn't loaded right away (after all, it's possible that
603 -- nothing from B will be used). When we come across a use of
604 -- 'f', we need to know its fixity, and it's then, and only
605 -- then, that we load B.hi. That is what's happening here.
607 -- loadInterfaceForName will find B.hi even if B is a hidden module,
608 -- and that's what we want.
609 loadInterfaceForName doc name `thenM` \ iface -> do {
610 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
611 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
612 returnM (mi_fix_fn iface (nameOccName name))
615 doc = ptext (sLit "Checking fixity for") <+> ppr name
618 lookupTyFixityRn :: Located Name -> RnM Fixity
619 lookupTyFixityRn (L _ n) = lookupFixityRn n
622 lookupLocalDataTcNames :: RdrName -> RnM [Name]
623 -- GHC extension: look up both the tycon and data con
624 -- for con-like things
625 -- Complain if neither is in scope
626 lookupLocalDataTcNames rdr_name
627 | Just n <- isExact_maybe rdr_name
628 -- Special case for (:), which doesn't get into the GlobalRdrEnv
629 = return [n] -- For this we don't need to try the tycon too
631 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
632 ; case [gre_name gre | Just gre <- mb_gres] of
634 -- run for error reporting
635 ; unboundName rdr_name
637 names -> return names
640 dataTcOccs :: RdrName -> [RdrName]
641 -- If the input is a data constructor, return both it and a type
642 -- constructor. This is useful when we aren't sure which we are
645 | Just n <- isExact_maybe rdr_name -- Ghastly special case
646 , n `hasKey` consDataConKey = [rdr_name] -- see note below
647 | isDataOcc occ = [rdr_name_tc, rdr_name]
648 | otherwise = [rdr_name]
650 occ = rdrNameOcc rdr_name
651 rdr_name_tc = setRdrNameSpace rdr_name tcName
653 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
654 -- and setRdrNameSpace generates an Orig, which is fine
655 -- But it's not fine for (:), because there *is* no corresponding type
656 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
657 -- appear to be in scope (because Orig's simply allocate a new name-cache
658 -- entry) and then we get an error when we use dataTcOccs in
659 -- TcRnDriver.tcRnGetInfo. Large sigh.
662 %************************************************************************
665 Dealing with rebindable syntax is driven by the
666 Opt_NoImplicitPrelude dynamic flag.
668 In "deriving" code we don't want to use rebindable syntax
669 so we switch off the flag locally
672 %************************************************************************
674 Haskell 98 says that when you say "3" you get the "fromInteger" from the
675 Standard Prelude, regardless of what is in scope. However, to experiment
676 with having a language that is less coupled to the standard prelude, we're
677 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
678 happens to be in scope. Then you can
680 import MyPrelude as Prelude
681 to get the desired effect.
683 At the moment this just happens for
684 * fromInteger, fromRational on literals (in expressions and patterns)
685 * negate (in expressions)
686 * minus (arising from n+k patterns)
689 We store the relevant Name in the HsSyn tree, in
690 * HsIntegral/HsFractional/HsIsString
694 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
695 fromRationalName etc), but the renamer changes this to the appropriate user
696 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
698 We treat the orignal (standard) names as free-vars too, because the type checker
699 checks the type of the user thing against the type of the standard thing.
702 lookupSyntaxName :: Name -- The standard name
703 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
704 lookupSyntaxName std_name
705 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
706 if implicit_prelude then normal_case
708 -- Get the similarly named thing from the local environment
709 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
710 returnM (HsVar usr_name, unitFV usr_name)
712 normal_case = returnM (HsVar std_name, emptyFVs)
714 lookupSyntaxTable :: [Name] -- Standard names
715 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
716 lookupSyntaxTable std_names
717 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
718 if implicit_prelude then normal_case
720 -- Get the similarly named thing from the local environment
721 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
723 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
725 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
729 %*********************************************************
733 %*********************************************************
736 newLocalsRn :: [Located RdrName] -> RnM [Name]
737 newLocalsRn rdr_names_w_loc
738 = newUniqueSupply `thenM` \ us ->
739 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
741 mk (L loc rdr_name) uniq
742 | Just name <- isExact_maybe rdr_name = name
743 -- This happens in code generated by Template Haskell
744 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
745 -- We only bind unqualified names here
746 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
747 mkInternalName uniq (rdrNameOcc rdr_name) loc
749 ---------------------
750 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
751 checkDupAndShadowedRdrNames doc loc_rdr_names
752 = do { checkDupRdrNames doc loc_rdr_names
754 ; checkShadowedNames doc envs
755 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
757 ---------------------
758 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
762 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
763 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
765 -- Make fresh Names and extend the environment
766 newLocalsRn rdr_names_w_loc `thenM` \names ->
767 bindLocalNames names (enclosed_scope names)
769 bindLocalNames :: [Name] -> RnM a -> RnM a
770 bindLocalNames names enclosed_scope
771 = getLocalRdrEnv `thenM` \ name_env ->
772 setLocalRdrEnv (extendLocalRdrEnv name_env names)
775 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
776 bindLocalNamesFV names enclosed_scope
777 = do { (result, fvs) <- bindLocalNames names enclosed_scope
778 ; returnM (result, delListFromNameSet fvs names) }
781 -------------------------------------
782 -- binLocalsFVRn is the same as bindLocalsRn
783 -- except that it deals with free vars
784 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
785 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
786 bindLocatedLocalsFV doc rdr_names enclosed_scope
787 = bindLocatedLocalsRn doc rdr_names $ \ names ->
788 enclosed_scope names `thenM` \ (thing, fvs) ->
789 returnM (thing, delListFromNameSet fvs names)
791 -------------------------------------
792 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
793 -> ([LHsTyVarBndr Name] -> RnM a)
795 -- Haskell-98 binding of type variables; e.g. within a data type decl
796 bindTyVarsRn doc_str tyvar_names enclosed_scope
798 located_tyvars = hsLTyVarLocNames tyvar_names
800 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
801 enclosed_scope (zipWith replace tyvar_names names)
803 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
805 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
806 -- Find the type variables in the pattern type
807 -- signatures that must be brought into scope
808 bindPatSigTyVars tys thing_inside
809 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
810 ; if not scoped_tyvars then
813 do { name_env <- getLocalRdrEnv
814 ; let locd_tvs = [ tv | ty <- tys
815 , tv <- extractHsTyRdrTyVars ty
816 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
817 nubbed_tvs = nubBy eqLocated locd_tvs
818 -- The 'nub' is important. For example:
819 -- f (x :: t) (y :: t) = ....
820 -- We don't want to complain about binding t twice!
822 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
824 doc_sig = text "In a pattern type-signature"
826 bindPatSigTyVarsFV :: [LHsType RdrName]
829 bindPatSigTyVarsFV tys thing_inside
830 = bindPatSigTyVars tys $ \ tvs ->
831 thing_inside `thenM` \ (result,fvs) ->
832 returnM (result, fvs `delListFromNameSet` tvs)
834 bindSigTyVarsFV :: [Name]
837 bindSigTyVarsFV tvs thing_inside
838 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
839 ; if not scoped_tyvars then
842 bindLocalNamesFV tvs thing_inside }
844 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
845 -- This function is used only in rnSourceDecl on InstDecl
846 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
848 -------------------------------------
849 checkDupRdrNames :: SDoc
852 checkDupRdrNames doc_str rdr_names_w_loc
853 = -- Check for duplicated names in a binding group
854 mappM_ (dupNamesErr getLoc doc_str) dups
856 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
858 checkDupNames :: SDoc
861 checkDupNames doc_str names
862 = -- Check for duplicated names in a binding group
863 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
865 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
867 -------------------------------------
868 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
869 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
870 = ifOptM Opt_WarnNameShadowing $
871 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
872 ; mappM_ check_shadow loc_rdr_names }
874 check_shadow (loc, occ)
875 | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
876 | not (null gres) = complain (map pprNameProvenance gres)
877 | otherwise = return ()
879 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
880 mb_local = lookupLocalRdrOcc local_env occ
881 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
882 -- Make an Unqualified RdrName and look that up, so that
883 -- we don't find any GREs that are in scope qualified-only
887 %************************************************************************
889 \subsection{Free variable manipulation}
891 %************************************************************************
895 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
896 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
898 (ys, fvs_s) = unzip stuff
900 returnM (ys, plusFVs fvs_s)
902 -- because some of the rename functions are CPSed:
903 -- maps the function across the list from left to right;
904 -- collects all the free vars into one set
905 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
906 -> [a] -> ([b] -> RnM c) -> RnM c
908 mapFvRnCPS _ [] cont = cont []
909 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
910 mapFvRnCPS f xs $ \ xs' ->
915 %************************************************************************
917 \subsection{Envt utility functions}
919 %************************************************************************
922 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
923 warnUnusedModules mods
924 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
926 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
927 mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
928 <+> text "is imported, but nothing from it is used,",
929 nest 2 (ptext (sLit "except perhaps instances visible in")
931 ptext (sLit "To suppress this warning, use:")
932 <+> ptext (sLit "import") <+> ppr m <> parens empty ]
935 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
936 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
937 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
939 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
940 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
941 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
943 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
944 check_unused flag bound_names used_names
945 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
947 -------------------------
949 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
951 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
953 warnUnusedLocals :: [Name] -> RnM ()
954 warnUnusedLocals names
955 = warnUnusedBinds [(n,LocalDef) | n<-names]
957 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
958 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
959 where reportable (name,_)
960 | isWiredInName name = False -- Don't report unused wired-in names
961 -- Otherwise we get a zillion warnings
963 | otherwise = reportIfUnused (nameOccName name)
965 -------------------------
967 warnUnusedName :: (Name, Provenance) -> RnM ()
968 warnUnusedName (name, LocalDef)
969 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
970 (ptext (sLit "Defined but not used"))
972 warnUnusedName (name, Imported is)
975 warn spec = addUnusedWarning name span msg
977 span = importSpecLoc spec
978 pp_mod = quotes (ppr (importSpecModule spec))
979 msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
981 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
982 addUnusedWarning name span msg
985 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
986 <+> quotes (ppr name)]
990 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
991 addNameClashErrRn rdr_name names
992 = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
993 ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
996 msg1 = ptext (sLit "either") <+> mk_ref np1
997 msgs = [ptext (sLit " or") <+> mk_ref np | np <- nps]
998 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1000 shadowedNameWarn :: SDoc -> OccName -> [SDoc] -> SDoc
1001 shadowedNameWarn doc occ shadowed_locs
1002 = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1003 <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1004 nest 2 (vcat shadowed_locs)]
1007 unknownNameErr :: RdrName -> SDoc
1008 unknownNameErr rdr_name
1009 = vcat [ hang (ptext (sLit "Not in scope:"))
1010 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1011 <+> quotes (ppr rdr_name))
1014 extra | rdr_name == forall_tv_RDR
1015 = ptext (sLit "Perhaps you intended to use -XRankNTypes or similar flag")
1018 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1019 unknownSubordinateErr doc op -- Doc is "method of class" or
1020 -- "field of constructor"
1021 = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1023 badOrigBinding :: RdrName -> SDoc
1025 = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1026 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1028 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1029 dupNamesErr get_loc descriptor names
1030 = addErrAt big_loc $
1031 vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1032 locations, descriptor]
1034 locs = map get_loc names
1035 big_loc = foldr1 combineSrcSpans locs
1036 one_line = isOneLineSpan big_loc
1037 locations | one_line = empty
1038 | otherwise = ptext (sLit "Bound at:") <+>
1039 vcat (map ppr (sortLe (<=) locs))
1041 badQualBndrErr :: RdrName -> SDoc
1042 badQualBndrErr rdr_name
1043 = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name