2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
4 \section[RnEnv]{Environment manipulation for the renamer monad}
8 newTopSrcBinder, lookupFamInstDeclBndr,
9 lookupLocatedTopBndrRn, lookupTopBndrRn,
10 lookupLocatedOccRn, lookupOccRn,
11 lookupLocatedGlobalOccRn,
12 lookupGlobalOccRn, lookupGlobalOccRn_maybe,
13 lookupLocalDataTcNames, lookupSigOccRn,
14 lookupFixityRn, lookupTyFixityRn,
15 lookupInstDeclBndr, lookupSubBndr, lookupConstructorFields,
16 lookupSyntaxName, lookupSyntaxTable,
17 lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
18 getLookupOccRn, addUsedRdrNames,
20 newLocalBndrRn, newLocalBndrsRn, newIPNameRn,
21 bindLocalName, bindLocalNames, bindLocalNamesFV,
22 MiniFixityEnv, emptyFsEnv, extendFsEnv, lookupFsEnv,
24 bindLocatedLocalsFV, bindLocatedLocalsRn,
25 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
26 bindTyVarsRn, extendTyVarEnvFVRn,
28 checkDupRdrNames, checkDupAndShadowedRdrNames,
29 checkDupNames, checkDupAndShadowedNames,
30 addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,
31 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
32 warnUnusedTopBinds, warnUnusedLocalBinds,
33 dataTcOccs, unknownNameErr, kindSigErr, perhapsForallMsg
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, tcLookupField, isBrackStage )
46 import Id ( isRecordSelector )
47 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
48 nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
52 import DataCon ( dataConFieldLabels )
54 import Module ( Module, ModuleName )
55 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE,
56 consDataConKey, forall_tv_RDR )
59 import ErrUtils ( Message )
64 import ListSetOps ( removeDups )
69 import qualified Data.Set as Set
74 thenM :: Monad a => a b -> (b -> a c) -> a c
78 %*********************************************************
82 %*********************************************************
85 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
86 newTopSrcBinder this_mod (L loc rdr_name)
87 | Just name <- isExact_maybe rdr_name
88 = -- This is here to catch
89 -- (a) Exact-name binders created by Template Haskell
90 -- (b) The PrelBase defn of (say) [] and similar, for which
91 -- the parser reads the special syntax and returns an Exact RdrName
92 -- We are at a binding site for the name, so check first that it
93 -- the current module is the correct one; otherwise GHC can get
94 -- very confused indeed. This test rejects code like
95 -- data T = (,) Int Int
96 -- unless we are in GHC.Tup
97 ASSERT2( isExternalName name, ppr name )
98 do { unless (this_mod == nameModule name)
99 (addErrAt loc (badOrigBinding rdr_name))
103 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
104 = do { unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
105 (addErrAt loc (badOrigBinding rdr_name))
106 -- When reading External Core we get Orig names as binders,
107 -- but they should agree with the module gotten from the monad
109 -- We can get built-in syntax showing up here too, sadly. If you type
111 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
112 -- uses setRdrNameSpace to make it into a data constructors. At that point
113 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
114 -- Hence the badOrigBinding error message.
116 -- Except for the ":Main.main = ..." definition inserted into
117 -- the Main module; ugh!
119 -- Because of this latter case, we call newGlobalBinder with a module from
120 -- the RdrName, not from the environment. In principle, it'd be fine to
121 -- have an arbitrary mixture of external core definitions in a single module,
122 -- (apart from module-initialisation issues, perhaps).
123 ; newGlobalBinder rdr_mod rdr_occ loc }
124 --TODO, should pass the whole span
127 = do { unless (not (isQual rdr_name))
128 (addErrAt loc (badQualBndrErr rdr_name))
129 -- Binders should not be qualified; if they are, and with a different
130 -- module name, we we get a confusing "M.T is not in scope" error later
133 ; if isBrackStage stage then
134 -- We are inside a TH bracket, so make an *Internal* name
135 -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
136 do { uniq <- newUnique
137 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
140 newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
143 %*********************************************************
145 Source code occurrences
147 %*********************************************************
149 Looking up a name in the RnEnv.
151 Note [Type and class operator definitions]
152 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
153 We want to reject all of these unless we have -XTypeOperators (Trac #3265)
155 class a :*: b where ...
156 data (:*:) a b = ....
157 class (:*:) a b where ...
158 The latter two mean that we are not just looking for a
159 *syntactically-infix* declaration, but one that uses an operator
160 OccName. We use OccName.isSymOcc to detect that case, which isn't
161 terribly efficient, but there seems to be no better way.
164 lookupTopBndrRn :: RdrName -> RnM Name
165 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
168 Nothing -> do traceRn $ text "lookupTopBndrRn"
171 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
172 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
174 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
175 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
176 -- and there may be several imported 'f's too, which must not confuse us.
177 -- For example, this is OK:
179 -- infix 9 f -- The 'f' here does not need to be qualified
180 -- f x = x -- Nor here, of course
181 -- So we have to filter out the non-local ones.
183 -- A separate function (importsFromLocalDecls) reports duplicate top level
184 -- decls, so here it's safe just to choose an arbitrary one.
186 -- There should never be a qualified name in a binding position in Haskell,
187 -- but there can be if we have read in an external-Core file.
188 -- The Haskell parser checks for the illegal qualified name in Haskell
189 -- source files, so we don't need to do so here.
191 lookupTopBndrRn_maybe rdr_name
192 | Just name <- isExact_maybe rdr_name
195 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
196 -- This deals with the case of derived bindings, where
197 -- we don't bother to call newTopSrcBinder first
198 -- We assume there is no "parent" name
199 = do { loc <- getSrcSpanM
200 ; n <- newGlobalBinder rdr_mod rdr_occ loc
204 = do { -- Check for operators in type or class declarations
205 -- See Note [Type and class operator definitions]
206 let occ = rdrNameOcc rdr_name
207 ; when (isTcOcc occ && isSymOcc occ)
208 (do { op_ok <- doptM Opt_TypeOperators
209 ; unless op_ok (addErr (opDeclErr rdr_name)) })
211 ; mb_gre <- lookupGreLocalRn rdr_name
213 Nothing -> return Nothing
214 Just gre -> return (Just $ gre_name gre) }
217 -----------------------------------------------
218 lookupInstDeclBndr :: Name -> RdrName -> RnM Name
219 -- This is called on the method name on the left-hand side of an
220 -- instance declaration binding. eg. instance Functor T where
222 -- ^^^^ called on this
223 -- Regardless of how many unqualified fmaps are in scope, we want
224 -- the one that comes from the Functor class.
226 -- Furthermore, note that we take no account of whether the
227 -- name is only in scope qualified. I.e. even if method op is
228 -- in scope as M.op, we still allow plain 'op' on the LHS of
230 lookupInstDeclBndr cls rdr
231 = do { when (isQual rdr)
232 (addErr (badQualBndrErr rdr))
233 -- In an instance decl you aren't allowed
234 -- to use a qualified name for the method
235 -- (Although it'd make perfect sense.)
236 ; lookupSubBndr (ParentIs cls) doc rdr }
238 doc = ptext (sLit "method of class") <+> quotes (ppr cls)
240 -----------------------------------------------
241 lookupConstructorFields :: Name -> RnM [Name]
242 -- Look up the fields of a given constructor
243 -- * For constructors from this module, use the record field env,
244 -- which is itself gathered from the (as yet un-typechecked)
247 -- * For constructors from imported modules, use the *type* environment
248 -- since imported modles are already compiled, the info is conveniently
251 lookupConstructorFields con_name
252 = do { this_mod <- getModule
253 ; if nameIsLocalOrFrom this_mod con_name then
254 do { RecFields field_env _ <- getRecFieldEnv
255 ; return (lookupNameEnv field_env con_name `orElse` []) }
257 do { con <- tcLookupDataCon con_name
258 ; return (dataConFieldLabels con) } }
260 -----------------------------------------------
261 -- Used for record construction and pattern matching
262 -- When the -XDisambiguateRecordFields flag is on, take account of the
263 -- constructor name to disambiguate which field to use; it's just the
264 -- same as for instance decls
266 -- NB: Consider this:
267 -- module Foo where { data R = R { fld :: Int } }
268 -- module Odd where { import Foo; fld x = x { fld = 3 } }
269 -- Arguably this should work, because the reference to 'fld' is
270 -- unambiguous because there is only one field id 'fld' in scope.
271 -- But currently it's rejected.
273 lookupSubBndr :: Parent -- NoParent => just look it up as usual
274 -- ParentIs p => use p to disambiguate
277 lookupSubBndr parent doc rdr_name
278 | Just n <- isExact_maybe rdr_name -- This happens in derived code
281 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
282 = lookupOrig rdr_mod rdr_occ
284 | otherwise -- Find all the things the rdr-name maps to
285 = do { -- and pick the one with the right parent name
286 ; env <- getGlobalRdrEnv
287 ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
288 ; case pick parent gres of
289 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
290 -- The latter does pickGREs, but we want to allow 'x'
291 -- even if only 'M.x' is in scope
292 [gre] -> do { addUsedRdrNames (used_rdr_names gre)
293 ; return (gre_name gre) }
294 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
295 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> (ppr rdr_name $$ ppr gres))
296 ; return (mkUnboundName rdr_name) }
297 gres -> do { addNameClashErrRn rdr_name gres
298 ; return (gre_name (head gres)) } }
300 pick NoParent gres -- Normal lookup
301 = pickGREs rdr_name gres
302 pick (ParentIs p) gres -- Disambiguating lookup
303 | isUnqual rdr_name = filter (right_parent p) gres
304 | otherwise = filter (right_parent p) (pickGREs rdr_name gres)
306 right_parent p (GRE { gre_par = ParentIs p' }) = p==p'
307 right_parent _ _ = False
309 -- Note [Usage for sub-bndrs]
311 | isQual rdr_name = [rdr_name]
312 | otherwise = case gre_prov gre of
313 LocalDef -> [rdr_name]
314 Imported is -> map mk_qual_rdr is
315 mk_qual_rdr imp_spec = mkRdrQual (is_as (is_decl imp_spec)) rdr_occ
316 rdr_occ = rdrNameOcc rdr_name
318 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
319 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
321 -- If the family is declared locally, it will not yet be in the main
322 -- environment; hence, we pass in an extra one here, which we check first.
323 -- See "Note [Looking up family names in family instances]" in 'RnNames'.
325 lookupFamInstDeclBndr :: GlobalRdrEnv -> Located RdrName -> RnM Name
326 lookupFamInstDeclBndr tyclGroupEnv (L loc rdr_name)
328 case lookupGRE_RdrName rdr_name tyclGroupEnv of
329 (gre:_) -> return $ gre_name gre
330 -- if there is more than one, an error will be raised elsewhere
331 [] -> lookupOccRn rdr_name
334 Note [Usage for sub-bndrs]
335 ~~~~~~~~~~~~~~~~~~~~~~~~~~
337 import qualified M( C( f ) )
340 then is the qualified import M.f used? Obviously yes.
341 But the RdrName used in the instance decl is unqualified. In effect,
342 we fill in the qualification by looking for f's whose class is M.C
343 But when adding to the UsedRdrNames we must make that qualification
344 explicit, otherwise we get "Redundant import of M.C".
346 --------------------------------------------------
348 --------------------------------------------------
351 getLookupOccRn :: RnM (Name -> Maybe Name)
353 = getLocalRdrEnv `thenM` \ local_env ->
354 return (lookupLocalRdrOcc local_env . nameOccName)
356 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
357 lookupLocatedOccRn = wrapLocM lookupOccRn
359 -- lookupOccRn looks up an occurrence of a RdrName
360 lookupOccRn :: RdrName -> RnM Name
362 = getLocalRdrEnv `thenM` \ local_env ->
363 case lookupLocalRdrEnv local_env rdr_name of
364 Just name -> return name
365 Nothing -> lookupGlobalOccRn rdr_name
367 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
368 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
370 lookupGlobalOccRn :: RdrName -> RnM Name
371 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
372 -- environment. Adds an error message if the RdrName is not in scope.
373 -- Also has a special case for GHCi.
375 lookupGlobalOccRn rdr_name
376 = do { -- First look up the name in the normal environment.
377 mb_name <- lookupGlobalOccRn_maybe rdr_name
382 { -- We allow qualified names on the command line to refer to
383 -- *any* name exported by any module in scope, just as if there
384 -- was an "import qualified M" declaration for every module.
385 allow_qual <- doptM Opt_ImplicitImportQualified
387 -- This test is not expensive,
388 -- and only happens for failed lookups
389 ; if isQual rdr_name && allow_qual && mod == iNTERACTIVE
390 then lookupQualifiedName rdr_name
391 else unboundName rdr_name } } }
393 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
394 -- No filter function; does not report an error on failure
396 lookupGlobalOccRn_maybe rdr_name
397 | Just n <- isExact_maybe rdr_name -- This happens in derived code
400 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
401 = do { n <- lookupOrig rdr_mod rdr_occ; return (Just n) }
404 = do { mb_gre <- lookupGreRn_maybe rdr_name
406 Nothing -> return Nothing
407 Just gre -> return (Just (gre_name gre)) }
410 unboundName :: RdrName -> RnM Name
412 = do { addErr (unknownNameErr rdr_name)
413 ; env <- getGlobalRdrEnv;
414 ; traceRn (vcat [unknownNameErr rdr_name,
415 ptext (sLit "Global envt is:"),
416 nest 3 (pprGlobalRdrEnv env)])
417 ; return (mkUnboundName rdr_name) }
419 --------------------------------------------------
420 -- Lookup in the Global RdrEnv of the module
421 --------------------------------------------------
423 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
424 -- Just look up the RdrName in the GlobalRdrEnv
425 lookupGreRn_maybe rdr_name
426 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
428 lookupGreRn :: RdrName -> RnM GlobalRdrElt
429 -- If not found, add error message, and return a fake GRE
431 = do { mb_gre <- lookupGreRn_maybe rdr_name
433 Just gre -> return gre ;
435 { traceRn $ text "lookupGreRn"
436 ; name <- unboundName rdr_name
437 ; return (GRE { gre_name = name, gre_par = NoParent,
438 gre_prov = LocalDef }) }}}
440 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
441 -- Similar, but restricted to locally-defined things
442 lookupGreLocalRn rdr_name
443 = lookupGreRn_help rdr_name lookup_fn
445 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
447 lookupGreRn_help :: RdrName -- Only used in error message
448 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
449 -> RnM (Maybe GlobalRdrElt)
450 -- Checks for exactly one match; reports deprecations
451 -- Returns Nothing, without error, if too few
452 lookupGreRn_help rdr_name lookup
453 = do { env <- getGlobalRdrEnv
456 [gre] -> do { addUsedRdrName gre rdr_name
457 ; return (Just gre) }
458 gres -> do { addNameClashErrRn rdr_name gres
459 ; return (Just (head gres)) } }
461 addUsedRdrName :: GlobalRdrElt -> RdrName -> RnM ()
462 -- Record usage of imported RdrNames
463 addUsedRdrName gre rdr
464 | isLocalGRE gre = return ()
465 | otherwise = do { env <- getGblEnv
466 ; updMutVar (tcg_used_rdrnames env)
467 (\s -> Set.insert rdr s) }
469 addUsedRdrNames :: [RdrName] -> RnM ()
470 -- Record used sub-binders
471 -- We don't check for imported-ness here, because it's inconvenient
472 -- and not stritly necessary.
474 = do { env <- getGblEnv
475 ; updMutVar (tcg_used_rdrnames env)
476 (\s -> foldr Set.insert s rdrs) }
478 ------------------------------
480 ------------------------------
482 -- A qualified name on the command line can refer to any module at all: we
483 -- try to load the interface if we don't already have it.
484 lookupQualifiedName :: RdrName -> RnM Name
485 lookupQualifiedName rdr_name
486 | Just (mod,occ) <- isQual_maybe rdr_name
487 -- Note: we want to behave as we would for a source file import here,
488 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
489 = loadSrcInterface doc mod False Nothing `thenM` \ iface ->
492 (mod,avails) <- mi_exports iface,
494 name <- availNames avail,
496 ((mod,occ):ns) -> ASSERT (null ns)
498 _ -> unboundName rdr_name
501 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
503 doc = ptext (sLit "Need to find") <+> ppr rdr_name
506 lookupSigOccRn is used for type signatures and pragmas
512 It's clear that the 'f' in the signature must refer to A.f
513 The Haskell98 report does not stipulate this, but it will!
514 So we must treat the 'f' in the signature in the same way
515 as the binding occurrence of 'f', using lookupBndrRn
517 However, consider this case:
521 We don't want to say 'f' is out of scope; instead, we want to
522 return the imported 'f', so that later on the reanamer will
523 correctly report "misplaced type sig".
526 lookupSigOccRn :: Maybe NameSet -- Just ns => source file; these are the binders
528 -- Nothing => hs-boot file; signatures without
529 -- binders are expected
531 -> Located RdrName -> RnM (Located Name)
532 lookupSigOccRn mb_bound_names sig
533 = wrapLocM $ \ rdr_name ->
534 do { mb_name <- lookupBindGroupOcc mb_bound_names (hsSigDoc sig) rdr_name
536 Left err -> do { addErr err; return (mkUnboundName rdr_name) }
537 Right name -> return name }
539 lookupBindGroupOcc :: Maybe NameSet -- Just ns => source file; these are the binders
541 -- Nothing => hs-boot file; signatures without
542 -- binders are expected
544 -> RdrName -> RnM (Either Message Name)
545 -- Looks up the RdrName, expecting it to resolve to one of the
546 -- bound names passed in. If not, return an appropriate error message
547 lookupBindGroupOcc mb_bound_names what rdr_name
548 = do { local_env <- getLocalRdrEnv
549 ; case lookupLocalRdrEnv local_env rdr_name of
550 Just n -> check_local_name n
551 Nothing -> do -- Not defined in a nested scope
553 { env <- getGlobalRdrEnv
554 ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
555 ; case (filter isLocalGRE gres) of
556 (gre:_) -> check_local_name (gre_name gre)
557 -- If there is more than one local GRE for the
558 -- same OccName, that will be reported separately
559 [] | null gres -> bale_out_with empty
560 | otherwise -> bale_out_with import_msg
563 check_local_name name -- The name is in scope, and not imported
564 = case mb_bound_names of
565 Just bound_names | not (name `elemNameSet` bound_names)
566 -> bale_out_with local_msg
567 _other -> return (Right name)
570 = return (Left (sep [ ptext (sLit "The") <+> what
571 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
572 , nest 2 $ ptext (sLit "lacks an accompanying binding")]
575 local_msg = parens $ ptext (sLit "The") <+> what <+> ptext (sLit "must be given where")
576 <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
578 import_msg = parens $ ptext (sLit "You cannot give a") <+> what
579 <+> ptext (sLit "for an imported value")
582 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
583 -- GHC extension: look up both the tycon and data con
584 -- for con-like things
585 -- Complain if neither is in scope
586 lookupLocalDataTcNames bound_names what rdr_name
587 | Just n <- isExact_maybe rdr_name
588 -- Special case for (:), which doesn't get into the GlobalRdrEnv
589 = return [n] -- For this we don't need to try the tycon too
591 = do { mb_gres <- mapM (lookupBindGroupOcc (Just bound_names) what)
592 (dataTcOccs rdr_name)
593 ; let (errs, names) = splitEithers mb_gres
594 ; when (null names) (addErr (head errs)) -- Bleat about one only
597 dataTcOccs :: RdrName -> [RdrName]
598 -- If the input is a data constructor, return both it and a type
599 -- constructor. This is useful when we aren't sure which we are
602 | Just n <- isExact_maybe rdr_name -- Ghastly special case
603 , n `hasKey` consDataConKey = [rdr_name] -- see note below
604 | isDataOcc occ = [rdr_name, rdr_name_tc]
605 | otherwise = [rdr_name]
607 occ = rdrNameOcc rdr_name
608 rdr_name_tc = setRdrNameSpace rdr_name tcName
610 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
611 -- and setRdrNameSpace generates an Orig, which is fine
612 -- But it's not fine for (:), because there *is* no corresponding type
613 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
614 -- appear to be in scope (because Orig's simply allocate a new name-cache
615 -- entry) and then we get an error when we use dataTcOccs in
616 -- TcRnDriver.tcRnGetInfo. Large sigh.
620 %*********************************************************
624 %*********************************************************
627 --------------------------------
628 type FastStringEnv a = UniqFM a -- Keyed by FastString
631 emptyFsEnv :: FastStringEnv a
632 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
633 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
635 emptyFsEnv = emptyUFM
636 lookupFsEnv = lookupUFM
637 extendFsEnv = addToUFM
639 --------------------------------
640 type MiniFixityEnv = FastStringEnv (Located Fixity)
641 -- Mini fixity env for the names we're about
642 -- to bind, in a single binding group
644 -- It is keyed by the *FastString*, not the *OccName*, because
645 -- the single fixity decl infix 3 T
646 -- affects both the data constructor T and the type constrctor T
648 -- We keep the location so that if we find
649 -- a duplicate, we can report it sensibly
651 --------------------------------
652 -- Used for nested fixity decls to bind names along with their fixities.
653 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
655 addLocalFixities :: MiniFixityEnv -> [Name] -> RnM a -> RnM a
656 addLocalFixities mini_fix_env names thing_inside
657 = extendFixityEnv (mapCatMaybes find_fixity names) thing_inside
660 = case lookupFsEnv mini_fix_env (occNameFS occ) of
661 Just (L _ fix) -> Just (name, FixItem occ fix)
664 occ = nameOccName name
667 --------------------------------
668 lookupFixity is a bit strange.
670 * Nested local fixity decls are put in the local fixity env, which we
671 find with getFixtyEnv
673 * Imported fixities are found in the HIT or PIT
675 * Top-level fixity decls in this module may be for Names that are
676 either Global (constructors, class operations)
677 or Local/Exported (everything else)
678 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
679 We put them all in the local fixity environment
682 lookupFixityRn :: Name -> RnM Fixity
684 = getModule `thenM` \ this_mod ->
685 if nameIsLocalOrFrom this_mod name
686 then do -- It's defined in this module
687 local_fix_env <- getFixityEnv
688 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
689 vcat [ppr name, ppr local_fix_env])
690 return $ lookupFixity local_fix_env name
691 else -- It's imported
692 -- For imported names, we have to get their fixities by doing a
693 -- loadInterfaceForName, and consulting the Ifaces that comes back
694 -- from that, because the interface file for the Name might not
695 -- have been loaded yet. Why not? Suppose you import module A,
696 -- which exports a function 'f', thus;
697 -- module CurrentModule where
699 -- module A( f ) where
701 -- Then B isn't loaded right away (after all, it's possible that
702 -- nothing from B will be used). When we come across a use of
703 -- 'f', we need to know its fixity, and it's then, and only
704 -- then, that we load B.hi. That is what's happening here.
706 -- loadInterfaceForName will find B.hi even if B is a hidden module,
707 -- and that's what we want.
708 loadInterfaceForName doc name `thenM` \ iface -> do {
709 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
710 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
711 return (mi_fix_fn iface (nameOccName name))
714 doc = ptext (sLit "Checking fixity for") <+> ppr name
717 lookupTyFixityRn :: Located Name -> RnM Fixity
718 lookupTyFixityRn (L _ n) = lookupFixityRn n
722 %************************************************************************
725 Dealing with rebindable syntax is driven by the
726 Opt_NoImplicitPrelude dynamic flag.
728 In "deriving" code we don't want to use rebindable syntax
729 so we switch off the flag locally
732 %************************************************************************
734 Haskell 98 says that when you say "3" you get the "fromInteger" from the
735 Standard Prelude, regardless of what is in scope. However, to experiment
736 with having a language that is less coupled to the standard prelude, we're
737 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
738 happens to be in scope. Then you can
740 import MyPrelude as Prelude
741 to get the desired effect.
743 At the moment this just happens for
744 * fromInteger, fromRational on literals (in expressions and patterns)
745 * negate (in expressions)
746 * minus (arising from n+k patterns)
749 We store the relevant Name in the HsSyn tree, in
750 * HsIntegral/HsFractional/HsIsString
754 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
755 fromRationalName etc), but the renamer changes this to the appropriate user
756 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
758 We treat the orignal (standard) names as free-vars too, because the type checker
759 checks the type of the user thing against the type of the standard thing.
762 lookupSyntaxName :: Name -- The standard name
763 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
764 lookupSyntaxName std_name
765 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
766 if implicit_prelude then normal_case
768 -- Get the similarly named thing from the local environment
769 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
770 return (HsVar usr_name, unitFV usr_name)
772 normal_case = return (HsVar std_name, emptyFVs)
774 lookupSyntaxTable :: [Name] -- Standard names
775 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
776 lookupSyntaxTable std_names
777 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
778 if implicit_prelude then normal_case
780 -- Get the similarly named thing from the local environment
781 mapM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
783 return (std_names `zip` map HsVar usr_names, mkFVs usr_names)
785 normal_case = return (std_names `zip` map HsVar std_names, emptyFVs)
789 %*********************************************************
793 %*********************************************************
796 newLocalBndrRn :: Located RdrName -> RnM Name
797 -- Used for non-top-level binders. These should
798 -- never be qualified.
799 newLocalBndrRn (L loc rdr_name)
800 | Just name <- isExact_maybe rdr_name
801 = return name -- This happens in code generated by Template Haskell
802 -- although I'm not sure why. Perhpas it's the call
803 -- in RnPat.newName LetMk?
805 = do { unless (isUnqual rdr_name)
806 (addErrAt loc (badQualBndrErr rdr_name))
808 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
810 newLocalBndrsRn :: [Located RdrName] -> RnM [Name]
811 newLocalBndrsRn = mapM newLocalBndrRn
813 ---------------------
814 bindLocatedLocalsRn :: [Located RdrName]
817 bindLocatedLocalsRn rdr_names_w_loc enclosed_scope
818 = do { checkDupAndShadowedRdrNames rdr_names_w_loc
820 -- Make fresh Names and extend the environment
821 ; names <- newLocalBndrsRn rdr_names_w_loc
822 ; bindLocalNames names (enclosed_scope names) }
824 bindLocalNames :: [Name] -> RnM a -> RnM a
825 bindLocalNames names enclosed_scope
826 = do { name_env <- getLocalRdrEnv
827 ; setLocalRdrEnv (extendLocalRdrEnvList name_env names)
830 bindLocalName :: Name -> RnM a -> RnM a
831 bindLocalName name enclosed_scope
832 = do { name_env <- getLocalRdrEnv
833 ; setLocalRdrEnv (extendLocalRdrEnv name_env name)
836 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
837 bindLocalNamesFV names enclosed_scope
838 = do { (result, fvs) <- bindLocalNames names enclosed_scope
839 ; return (result, delListFromNameSet fvs names) }
842 -------------------------------------
843 -- binLocalsFVRn is the same as bindLocalsRn
844 -- except that it deals with free vars
845 bindLocatedLocalsFV :: [Located RdrName]
846 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
847 bindLocatedLocalsFV rdr_names enclosed_scope
848 = bindLocatedLocalsRn rdr_names $ \ names ->
849 enclosed_scope names `thenM` \ (thing, fvs) ->
850 return (thing, delListFromNameSet fvs names)
852 -------------------------------------
853 bindTyVarsRn :: [LHsTyVarBndr RdrName]
854 -> ([LHsTyVarBndr Name] -> RnM a)
856 -- Haskell-98 binding of type variables; e.g. within a data type decl
857 bindTyVarsRn tyvar_names enclosed_scope
858 = bindLocatedLocalsRn located_tyvars $ \ names ->
859 do { kind_sigs_ok <- doptM Opt_KindSignatures
860 ; unless (null kinded_tyvars || kind_sigs_ok)
861 (mapM_ (addErr . kindSigErr) kinded_tyvars)
862 ; enclosed_scope (zipWith replace tyvar_names names) }
864 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
865 located_tyvars = hsLTyVarLocNames tyvar_names
866 kinded_tyvars = [n | L _ (KindedTyVar n _) <- tyvar_names]
868 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
869 -- Find the type variables in the pattern type
870 -- signatures that must be brought into scope
871 bindPatSigTyVars tys thing_inside
872 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
873 ; if not scoped_tyvars then
876 do { name_env <- getLocalRdrEnv
877 ; let locd_tvs = [ tv | ty <- tys
878 , tv <- extractHsTyRdrTyVars ty
879 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
880 nubbed_tvs = nubBy eqLocated locd_tvs
881 -- The 'nub' is important. For example:
882 -- f (x :: t) (y :: t) = ....
883 -- We don't want to complain about binding t twice!
885 ; bindLocatedLocalsRn nubbed_tvs thing_inside }}
887 bindPatSigTyVarsFV :: [LHsType RdrName]
890 bindPatSigTyVarsFV tys thing_inside
891 = bindPatSigTyVars tys $ \ tvs ->
892 thing_inside `thenM` \ (result,fvs) ->
893 return (result, fvs `delListFromNameSet` tvs)
895 bindSigTyVarsFV :: [Name]
898 bindSigTyVarsFV tvs thing_inside
899 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
900 ; if not scoped_tyvars then
903 bindLocalNamesFV tvs thing_inside }
905 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
906 -- This function is used only in rnSourceDecl on InstDecl
907 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
909 -------------------------------------
910 checkDupRdrNames :: [Located RdrName] -> RnM ()
911 checkDupRdrNames rdr_names_w_loc
912 = -- Check for duplicated names in a binding group
913 mapM_ (dupNamesErr getLoc) dups
915 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
917 checkDupNames :: [Name] -> RnM ()
919 = -- Check for duplicated names in a binding group
920 mapM_ (dupNamesErr nameSrcSpan) dups
922 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
924 ---------------------
925 checkDupAndShadowedRdrNames :: [Located RdrName] -> RnM ()
926 checkDupAndShadowedRdrNames loc_rdr_names
927 = do { checkDupRdrNames loc_rdr_names
929 ; checkShadowedOccs envs loc_occs }
931 loc_occs = [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names]
933 checkDupAndShadowedNames :: (GlobalRdrEnv, LocalRdrEnv) -> [Name] -> RnM ()
934 checkDupAndShadowedNames envs names
935 = do { checkDupNames names
936 ; checkShadowedOccs envs loc_occs }
938 loc_occs = [(nameSrcSpan name, nameOccName name) | name <- names]
940 -------------------------------------
941 checkShadowedOccs :: (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
942 checkShadowedOccs (global_env,local_env) loc_occs
943 = ifOptM Opt_WarnNameShadowing $
944 do { traceRn (text "shadow" <+> ppr loc_occs)
945 ; mapM_ check_shadow loc_occs }
947 check_shadow (loc, occ)
948 | startsWithUnderscore occ = return () -- Do not report shadowing for "_x"
950 | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
951 | otherwise = do { gres' <- filterM is_shadowed_gre gres
952 ; complain (map pprNameProvenance gres') }
954 complain [] = return ()
955 complain pp_locs = addWarnAt loc (shadowedNameWarn occ pp_locs)
956 mb_local = lookupLocalRdrOcc local_env occ
957 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
958 -- Make an Unqualified RdrName and look that up, so that
959 -- we don't find any GREs that are in scope qualified-only
961 is_shadowed_gre :: GlobalRdrElt -> RnM Bool
962 -- Returns False for record selectors that are shadowed, when
963 -- punning or wild-cards are on (cf Trac #2723)
964 is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
965 = do { dflags <- getDOpts
966 ; if (dopt Opt_RecordPuns dflags || dopt Opt_RecordWildCards dflags)
967 then do { is_fld <- is_rec_fld gre; return (not is_fld) }
969 is_shadowed_gre _other = return True
971 is_rec_fld gre -- Return True for record selector ids
972 | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
973 ; return (gre_name gre `elemNameSet` fld_set) }
974 | otherwise = do { sel_id <- tcLookupField (gre_name gre)
975 ; return (isRecordSelector sel_id) }
979 %************************************************************************
981 \subsection{Free variable manipulation}
983 %************************************************************************
987 addFvRn :: FreeVars -> RnM (thing, FreeVars) -> RnM (thing, FreeVars)
988 addFvRn fvs1 thing_inside = do { (res, fvs2) <- thing_inside
989 ; return (res, fvs1 `plusFV` fvs2) }
991 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
992 mapFvRn f xs = do stuff <- mapM f xs
994 (ys, fvs_s) -> return (ys, plusFVs fvs_s)
996 mapMaybeFvRn :: (a -> RnM (b, FreeVars)) -> Maybe a -> RnM (Maybe b, FreeVars)
997 mapMaybeFvRn _ Nothing = return (Nothing, emptyFVs)
998 mapMaybeFvRn f (Just x) = do { (y, fvs) <- f x; return (Just y, fvs) }
1000 -- because some of the rename functions are CPSed:
1001 -- maps the function across the list from left to right;
1002 -- collects all the free vars into one set
1003 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
1004 -> [a] -> ([b] -> RnM c) -> RnM c
1006 mapFvRnCPS _ [] cont = cont []
1007 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
1008 mapFvRnCPS f xs $ \ xs' ->
1013 %************************************************************************
1015 \subsection{Envt utility functions}
1017 %************************************************************************
1020 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
1021 warnUnusedModules mods
1022 = ifOptM Opt_WarnUnusedImports (mapM_ bleat mods)
1024 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
1025 mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
1026 <+> text "is imported, but nothing from it is used,",
1027 nest 2 (ptext (sLit "except perhaps instances visible in")
1028 <+> quotes (ppr m)),
1029 ptext (sLit "To suppress this warning, use:")
1030 <+> ptext (sLit "import") <+> ppr m <> parens empty ]
1033 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
1034 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
1035 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
1037 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1038 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1039 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
1041 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
1042 check_unused flag bound_names used_names
1043 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1045 -------------------------
1047 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1049 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1051 warnUnusedLocals :: [Name] -> RnM ()
1052 warnUnusedLocals names
1053 = warnUnusedBinds [(n,LocalDef) | n<-names]
1055 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1056 warnUnusedBinds names = mapM_ warnUnusedName (filter reportable names)
1057 where reportable (name,_)
1058 | isWiredInName name = False -- Don't report unused wired-in names
1059 -- Otherwise we get a zillion warnings
1061 | otherwise = not (startsWithUnderscore (nameOccName name))
1063 -------------------------
1065 warnUnusedName :: (Name, Provenance) -> RnM ()
1066 warnUnusedName (name, LocalDef)
1067 = addUnusedWarning name (nameSrcSpan name)
1068 (ptext (sLit "Defined but not used"))
1070 warnUnusedName (name, Imported is)
1073 warn spec = addUnusedWarning name span msg
1075 span = importSpecLoc spec
1076 pp_mod = quotes (ppr (importSpecModule spec))
1077 msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1079 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1080 addUnusedWarning name span msg
1083 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1084 <+> quotes (ppr name)]
1088 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1089 addNameClashErrRn rdr_name names
1090 = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1091 ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1094 msg1 = ptext (sLit "either") <+> mk_ref np1
1095 msgs = [ptext (sLit " or") <+> mk_ref np | np <- nps]
1096 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1098 shadowedNameWarn :: OccName -> [SDoc] -> SDoc
1099 shadowedNameWarn occ shadowed_locs
1100 = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1101 <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1102 nest 2 (vcat shadowed_locs)]
1104 unknownNameErr :: RdrName -> SDoc
1105 unknownNameErr rdr_name
1106 = vcat [ hang (ptext (sLit "Not in scope:"))
1107 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1108 <+> quotes (ppr rdr_name))
1111 extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1114 perhapsForallMsg :: SDoc
1116 = vcat [ ptext (sLit "Perhaps you intended to use -XExplicitForAll or similar flag")
1117 , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1119 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1120 unknownSubordinateErr doc op -- Doc is "method of class" or
1121 -- "field of constructor"
1122 = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1124 badOrigBinding :: RdrName -> SDoc
1126 = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1127 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1129 dupNamesErr :: Outputable n => (n -> SrcSpan) -> [n] -> RnM ()
1130 dupNamesErr get_loc names
1131 = addErrAt big_loc $
1132 vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1135 locs = map get_loc names
1136 big_loc = foldr1 combineSrcSpans locs
1137 locations = ptext (sLit "Bound at:") <+> vcat (map ppr (sortLe (<=) locs))
1139 kindSigErr :: Outputable a => a -> SDoc
1141 = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
1142 2 (ptext (sLit "Perhaps you intended to use -XKindSignatures"))
1145 badQualBndrErr :: RdrName -> SDoc
1146 badQualBndrErr rdr_name
1147 = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
1149 opDeclErr :: RdrName -> SDoc
1151 = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
1152 2 (ptext (sLit "Use -XTypeOperators to declare operators in type and declarations"))