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, lookupRecordBndr, lookupConstructorFields,
16 lookupSyntaxName, lookupSyntaxTable,
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, 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, hasKey, forall_tv_RDR )
58 import BasicTypes ( IPName, mapIPName, Fixity )
59 import ErrUtils ( Message )
64 import ListSetOps ( removeDups )
73 thenM :: Monad a => a b -> (b -> a c) -> a c
76 thenM_ :: Monad a => a b -> a c -> a c
79 returnM :: Monad m => a -> m a
82 mappM :: (Monad m) => (a -> m b) -> [a] -> m [b]
85 mappM_ :: (Monad m) => (a -> m b) -> [a] -> m ()
88 checkM :: Monad m => Bool -> m () -> m ()
92 %*********************************************************
96 %*********************************************************
99 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
100 newTopSrcBinder this_mod (L loc rdr_name)
101 | Just name <- isExact_maybe rdr_name
102 = -- This is here to catch
103 -- (a) Exact-name binders created by Template Haskell
104 -- (b) The PrelBase defn of (say) [] and similar, for which
105 -- the parser reads the special syntax and returns an Exact RdrName
106 -- We are at a binding site for the name, so check first that it
107 -- the current module is the correct one; otherwise GHC can get
108 -- very confused indeed. This test rejects code like
109 -- data T = (,) Int Int
110 -- unless we are in GHC.Tup
111 ASSERT2( isExternalName name, ppr name )
112 do { checkM (this_mod == nameModule name)
113 (addErrAt loc (badOrigBinding rdr_name))
117 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
118 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
119 (addErrAt loc (badOrigBinding rdr_name))
120 -- When reading External Core we get Orig names as binders,
121 -- but they should agree with the module gotten from the monad
123 -- We can get built-in syntax showing up here too, sadly. If you type
125 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
126 -- uses setRdrNameSpace to make it into a data constructors. At that point
127 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
128 -- Hence the badOrigBinding error message.
130 -- Except for the ":Main.main = ..." definition inserted into
131 -- the Main module; ugh!
133 -- Because of this latter case, we call newGlobalBinder with a module from
134 -- the RdrName, not from the environment. In principle, it'd be fine to
135 -- have an arbitrary mixture of external core definitions in a single module,
136 -- (apart from module-initialisation issues, perhaps).
137 ; newGlobalBinder rdr_mod rdr_occ loc }
138 --TODO, should pass the whole span
141 = do { checkM (not (isQual rdr_name))
142 (addErrAt loc (badQualBndrErr rdr_name))
143 -- Binders should not be qualified; if they are, and with a different
144 -- module name, we we get a confusing "M.T is not in scope" error later
147 ; if isBrackStage stage then
148 -- We are inside a TH bracket, so make an *Internal* name
149 -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
150 do { uniq <- newUnique
151 ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
154 newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
157 %*********************************************************
159 Source code occurrences
161 %*********************************************************
163 Looking up a name in the RnEnv.
166 lookupTopBndrRn :: RdrName -> RnM Name
167 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
170 Nothing -> do traceRn $ text "lookupTopBndrRn"
173 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
174 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
176 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
177 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
178 -- and there may be several imported 'f's too, which must not confuse us.
179 -- For example, this is OK:
181 -- infix 9 f -- The 'f' here does not need to be qualified
182 -- f x = x -- Nor here, of course
183 -- So we have to filter out the non-local ones.
185 -- A separate function (importsFromLocalDecls) reports duplicate top level
186 -- decls, so here it's safe just to choose an arbitrary one.
188 -- There should never be a qualified name in a binding position in Haskell,
189 -- but there can be if we have read in an external-Core file.
190 -- The Haskell parser checks for the illegal qualified name in Haskell
191 -- source files, so we don't need to do so here.
193 lookupTopBndrRn_maybe rdr_name
194 | Just name <- isExact_maybe rdr_name
195 = returnM (Just name)
197 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
198 -- This deals with the case of derived bindings, where
199 -- we don't bother to call newTopSrcBinder first
200 -- We assume there is no "parent" name
201 = do { loc <- getSrcSpanM
202 ; n <- newGlobalBinder rdr_mod rdr_occ loc
206 = do { mb_gre <- lookupGreLocalRn rdr_name
208 Nothing -> returnM Nothing
209 Just gre -> returnM (Just $ gre_name gre) }
212 -----------------------------------------------
213 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
214 -- This is called on the method name on the left-hand side of an
215 -- instance declaration binding. eg. instance Functor T where
217 -- ^^^^ called on this
218 -- Regardless of how many unqualified fmaps are in scope, we want
219 -- the one that comes from the Functor class.
221 -- Furthermore, note that we take no account of whether the
222 -- name is only in scope qualified. I.e. even if method op is
223 -- in scope as M.op, we still allow plain 'op' on the LHS of
225 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
227 doc = ptext (sLit "method of class") <+> quotes (ppr cls)
228 is_op (GRE {gre_par = ParentIs n}) = n == cls
231 -----------------------------------------------
232 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
233 -- Used for record construction and pattern matching
234 -- When the -XDisambiguateRecordFields flag is on, take account of the
235 -- constructor name to disambiguate which field to use; it's just the
236 -- same as for instance decls
238 -- NB: Consider this:
239 -- module Foo where { data R = R { fld :: Int } }
240 -- module Odd where { import Foo; fld x = x { fld = 3 } }
241 -- Arguably this should work, because the reference to 'fld' is
242 -- unambiguous because there is only one field id 'fld' in scope.
243 -- But currently it's rejected.
244 lookupRecordBndr Nothing rdr_name
245 = lookupLocatedGlobalOccRn rdr_name
246 lookupRecordBndr (Just (L _ data_con)) rdr_name
247 = do { flag_on <- doptM Opt_DisambiguateRecordFields
249 then lookupLocatedGlobalOccRn rdr_name
251 fields <- lookupConstructorFields data_con
252 ; let is_field gre = gre_name gre `elem` fields
253 ; lookup_located_sub_bndr is_field doc rdr_name
256 doc = ptext (sLit "field of constructor") <+> quotes (ppr data_con)
259 lookupConstructorFields :: Name -> RnM [Name]
260 -- Look up the fields of a given constructor
261 -- * For constructors from this module, use the record field env,
262 -- which is itself gathered from the (as yet un-typechecked)
265 -- * For constructors from imported modules, use the *type* environment
266 -- since imported modles are already compiled, the info is conveniently
269 lookupConstructorFields con_name
270 = do { this_mod <- getModule
271 ; if nameIsLocalOrFrom this_mod con_name then
272 do { RecFields field_env _ <- getRecFieldEnv
273 ; return (lookupNameEnv field_env con_name `orElse` []) }
275 do { con <- tcLookupDataCon con_name
276 ; return (dataConFieldLabels con) } }
278 -----------------------------------------------
279 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
280 -> SDoc -> Located RdrName
281 -> RnM (Located Name)
282 lookup_located_sub_bndr is_good doc rdr_name
283 = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
285 lookup_sub_bndr :: (GlobalRdrElt -> Bool) -> SDoc -> RdrName -> RnM Name
286 lookup_sub_bndr is_good doc rdr_name
287 | isUnqual rdr_name -- Find all the things the rdr-name maps to
288 = do { -- and pick the one with the right parent name
289 ; env <- getGlobalRdrEnv
290 ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
291 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
292 -- The latter does pickGREs, but we want to allow 'x'
293 -- even if only 'M.x' is in scope
294 [gre] -> return (gre_name gre)
295 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
296 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
297 ; return (mkUnboundName rdr_name) }
298 gres -> do { addNameClashErrRn rdr_name gres
299 ; return (gre_name (head gres)) }
302 | otherwise -- Occurs in derived instances, where we just
303 -- refer directly to the right method with an Orig
304 -- And record fields can be Quals: C { F.f = x }
305 = lookupGlobalOccRn rdr_name
307 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
308 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
310 -- Looking up family names in type instances is a subtle affair. The family
311 -- may be imported, in which case we need to lookup the occurence of a global
312 -- name. Alternatively, the family may be in the same binding group (and in
313 -- fact in a declaration processed later), and we need to create a new top
316 -- So, also this is strictly speaking an occurence, we cannot raise an error
317 -- message yet for instances without a family declaration. This will happen
318 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
320 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
321 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
322 = do { mb_gre <- lookupGreRn_maybe rdr_name
324 Just gre -> returnM (gre_name gre)
325 Nothing -> newTopSrcBinder mod lrdr_name }
327 --------------------------------------------------
329 --------------------------------------------------
331 getLookupOccRn :: RnM (Name -> Maybe Name)
333 = getLocalRdrEnv `thenM` \ local_env ->
334 return (lookupLocalRdrOcc local_env . nameOccName)
336 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
337 lookupLocatedOccRn = wrapLocM lookupOccRn
339 -- lookupOccRn looks up an occurrence of a RdrName
340 lookupOccRn :: RdrName -> RnM Name
342 = getLocalRdrEnv `thenM` \ local_env ->
343 case lookupLocalRdrEnv local_env rdr_name of
344 Just name -> returnM name
345 Nothing -> lookupGlobalOccRn rdr_name
347 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
348 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
350 lookupGlobalOccRn :: RdrName -> RnM Name
351 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
352 -- environment. Adds an error message if the RdrName is not in scope.
353 -- Also has a special case for GHCi.
355 lookupGlobalOccRn rdr_name
356 = do { -- First look up the name in the normal environment.
357 mb_name <- lookupGlobalOccRn_maybe rdr_name
362 { -- We allow qualified names on the command line to refer to
363 -- *any* name exported by any module in scope, just as if there
364 -- was an "import qualified M" declaration for every module.
365 allow_qual <- doptM Opt_ImplicitImportQualified
367 -- This test is not expensive,
368 -- and only happens for failed lookups
369 ; if isQual rdr_name && allow_qual && mod == iNTERACTIVE
370 then lookupQualifiedName rdr_name
371 else unboundName rdr_name } } }
373 lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
374 -- No filter function; does not report an error on failure
376 lookupGlobalOccRn_maybe rdr_name
377 | Just n <- isExact_maybe rdr_name -- This happens in derived code
380 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
381 = do { n <- lookupOrig rdr_mod rdr_occ; return (Just n) }
384 = do { mb_gre <- lookupGreRn_maybe rdr_name
386 Nothing -> return Nothing
387 Just gre -> return (Just (gre_name gre)) }
390 unboundName :: RdrName -> RnM Name
392 = do { addErr (unknownNameErr rdr_name)
393 ; env <- getGlobalRdrEnv;
394 ; traceRn (vcat [unknownNameErr rdr_name,
395 ptext (sLit "Global envt is:"),
396 nest 3 (pprGlobalRdrEnv env)])
397 ; returnM (mkUnboundName rdr_name) }
399 --------------------------------------------------
400 -- Lookup in the Global RdrEnv of the module
401 --------------------------------------------------
403 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
404 -- Just look up the RdrName in the GlobalRdrEnv
405 lookupGreRn_maybe rdr_name
406 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
408 lookupGreRn :: RdrName -> RnM GlobalRdrElt
409 -- If not found, add error message, and return a fake GRE
411 = do { mb_gre <- lookupGreRn_maybe rdr_name
413 Just gre -> return gre ;
415 { traceRn $ text "lookupGreRn"
416 ; name <- unboundName rdr_name
417 ; return (GRE { gre_name = name, gre_par = NoParent,
418 gre_prov = LocalDef }) }}}
420 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
421 -- Similar, but restricted to locally-defined things
422 lookupGreLocalRn rdr_name
423 = lookupGreRn_help rdr_name lookup_fn
425 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
427 lookupGreRn_help :: RdrName -- Only used in error message
428 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
429 -> RnM (Maybe GlobalRdrElt)
430 -- Checks for exactly one match; reports deprecations
431 -- Returns Nothing, without error, if too few
432 lookupGreRn_help rdr_name lookup
433 = do { env <- getGlobalRdrEnv
435 [] -> returnM Nothing
436 [gre] -> returnM (Just gre)
437 gres -> do { addNameClashErrRn rdr_name gres
438 ; returnM (Just (head gres)) } }
440 ------------------------------
442 ------------------------------
444 -- A qualified name on the command line can refer to any module at all: we
445 -- try to load the interface if we don't already have it.
446 lookupQualifiedName :: RdrName -> RnM Name
447 lookupQualifiedName rdr_name
448 | Just (mod,occ) <- isQual_maybe rdr_name
449 -- Note: we want to behave as we would for a source file import here,
450 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
451 = loadSrcInterface doc mod False Nothing `thenM` \ iface ->
454 (mod,avails) <- mi_exports iface,
456 name <- availNames avail,
458 ((mod,occ):ns) -> ASSERT (null ns)
460 _ -> unboundName rdr_name
463 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
465 doc = ptext (sLit "Need to find") <+> ppr rdr_name
468 lookupSigOccRn is used for type signatures and pragmas
474 It's clear that the 'f' in the signature must refer to A.f
475 The Haskell98 report does not stipulate this, but it will!
476 So we must treat the 'f' in the signature in the same way
477 as the binding occurrence of 'f', using lookupBndrRn
479 However, consider this case:
483 We don't want to say 'f' is out of scope; instead, we want to
484 return the imported 'f', so that later on the reanamer will
485 correctly report "misplaced type sig".
488 lookupSigOccRn :: Maybe NameSet -- Just ns => source file; these are the binders
490 -- Nothing => hs-boot file; signatures without
491 -- binders are expected
493 -> Located RdrName -> RnM (Located Name)
494 lookupSigOccRn mb_bound_names sig
495 = wrapLocM $ \ rdr_name ->
496 do { mb_name <- lookupBindGroupOcc mb_bound_names (hsSigDoc sig) rdr_name
498 Left err -> do { addErr err; return (mkUnboundName rdr_name) }
499 Right name -> return name }
501 lookupBindGroupOcc :: Maybe NameSet -- Just ns => source file; these are the binders
503 -- Nothing => hs-boot file; signatures without
504 -- binders are expected
506 -> RdrName -> RnM (Either Message Name)
507 -- Looks up the RdrName, expecting it to resolve to one of the
508 -- bound names passed in. If not, return an appropriate error message
509 lookupBindGroupOcc mb_bound_names what rdr_name
510 = do { local_env <- getLocalRdrEnv
511 ; case lookupLocalRdrEnv local_env rdr_name of
512 Just n -> check_local_name n
513 Nothing -> do -- Not defined in a nested scope
515 { env <- getGlobalRdrEnv
516 ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
517 ; case (filter isLocalGRE gres) of
518 (gre:_) -> check_local_name (gre_name gre)
519 -- If there is more than one local GRE for the
520 -- same OccName, that will be reported separately
521 [] | null gres -> bale_out_with empty
522 | otherwise -> bale_out_with import_msg
525 check_local_name name -- The name is in scope, and not imported
526 = case mb_bound_names of
527 Just bound_names | not (name `elemNameSet` bound_names)
528 -> bale_out_with local_msg
529 _other -> return (Right name)
532 = return (Left (sep [ ptext (sLit "The") <+> what
533 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
534 , nest 2 $ ptext (sLit "lacks an accompanying binding")]
537 local_msg = parens $ ptext (sLit "The") <+> what <+> ptext (sLit "must be given where")
538 <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
540 import_msg = parens $ ptext (sLit "You cannot give a") <+> what
541 <+> ptext (sLit "for an imported value")
544 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
545 -- GHC extension: look up both the tycon and data con
546 -- for con-like things
547 -- Complain if neither is in scope
548 lookupLocalDataTcNames bound_names what rdr_name
549 | Just n <- isExact_maybe rdr_name
550 -- Special case for (:), which doesn't get into the GlobalRdrEnv
551 = return [n] -- For this we don't need to try the tycon too
553 = do { mb_gres <- mapM (lookupBindGroupOcc (Just bound_names) what)
554 (dataTcOccs rdr_name)
555 ; let (errs, names) = splitEithers mb_gres
556 ; when (null names) (addErr (head errs)) -- Bleat about one only
559 dataTcOccs :: RdrName -> [RdrName]
560 -- If the input is a data constructor, return both it and a type
561 -- constructor. This is useful when we aren't sure which we are
564 | Just n <- isExact_maybe rdr_name -- Ghastly special case
565 , n `hasKey` consDataConKey = [rdr_name] -- see note below
566 | isDataOcc occ = [rdr_name, rdr_name_tc]
567 | otherwise = [rdr_name]
569 occ = rdrNameOcc rdr_name
570 rdr_name_tc = setRdrNameSpace rdr_name tcName
572 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
573 -- and setRdrNameSpace generates an Orig, which is fine
574 -- But it's not fine for (:), because there *is* no corresponding type
575 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
576 -- appear to be in scope (because Orig's simply allocate a new name-cache
577 -- entry) and then we get an error when we use dataTcOccs in
578 -- TcRnDriver.tcRnGetInfo. Large sigh.
582 %*********************************************************
586 %*********************************************************
589 --------------------------------
590 type FastStringEnv a = UniqFM a -- Keyed by FastString
593 emptyFsEnv :: FastStringEnv a
594 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
595 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
597 emptyFsEnv = emptyUFM
598 lookupFsEnv = lookupUFM
599 extendFsEnv = addToUFM
601 --------------------------------
602 type MiniFixityEnv = FastStringEnv (Located Fixity)
603 -- Mini fixity env for the names we're about
604 -- to bind, in a single binding group
606 -- It is keyed by the *FastString*, not the *OccName*, because
607 -- the single fixity decl infix 3 T
608 -- affects both the data constructor T and the type constrctor T
610 -- We keep the location so that if we find
611 -- a duplicate, we can report it sensibly
613 --------------------------------
614 -- Used for nested fixity decls to bind names along with their fixities.
615 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
616 -- Also check for unused binders
617 bindLocalNamesFV_WithFixities :: [Name]
619 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
620 bindLocalNamesFV_WithFixities names fixities thing_inside
621 = bindLocalNamesFV names $
622 extendFixityEnv boundFixities $
625 -- find the names that have fixity decls
626 boundFixities = foldr
628 -- check whether this name has a fixity decl
629 case lookupFsEnv fixities (occNameFS (nameOccName name)) of
630 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
631 Nothing -> acc) [] names
632 -- bind the names; extend the fixity env; do the thing inside
635 --------------------------------
636 lookupFixity is a bit strange.
638 * Nested local fixity decls are put in the local fixity env, which we
639 find with getFixtyEnv
641 * Imported fixities are found in the HIT or PIT
643 * Top-level fixity decls in this module may be for Names that are
644 either Global (constructors, class operations)
645 or Local/Exported (everything else)
646 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
647 We put them all in the local fixity environment
650 lookupFixityRn :: Name -> RnM Fixity
652 = getModule `thenM` \ this_mod ->
653 if nameIsLocalOrFrom this_mod name
654 then do -- It's defined in this module
655 local_fix_env <- getFixityEnv
656 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
657 vcat [ppr name, ppr local_fix_env])
658 return $ lookupFixity local_fix_env name
659 else -- It's imported
660 -- For imported names, we have to get their fixities by doing a
661 -- loadInterfaceForName, and consulting the Ifaces that comes back
662 -- from that, because the interface file for the Name might not
663 -- have been loaded yet. Why not? Suppose you import module A,
664 -- which exports a function 'f', thus;
665 -- module CurrentModule where
667 -- module A( f ) where
669 -- Then B isn't loaded right away (after all, it's possible that
670 -- nothing from B will be used). When we come across a use of
671 -- 'f', we need to know its fixity, and it's then, and only
672 -- then, that we load B.hi. That is what's happening here.
674 -- loadInterfaceForName will find B.hi even if B is a hidden module,
675 -- and that's what we want.
676 loadInterfaceForName doc name `thenM` \ iface -> do {
677 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
678 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
679 returnM (mi_fix_fn iface (nameOccName name))
682 doc = ptext (sLit "Checking fixity for") <+> ppr name
685 lookupTyFixityRn :: Located Name -> RnM Fixity
686 lookupTyFixityRn (L _ n) = lookupFixityRn n
690 %************************************************************************
693 Dealing with rebindable syntax is driven by the
694 Opt_NoImplicitPrelude dynamic flag.
696 In "deriving" code we don't want to use rebindable syntax
697 so we switch off the flag locally
700 %************************************************************************
702 Haskell 98 says that when you say "3" you get the "fromInteger" from the
703 Standard Prelude, regardless of what is in scope. However, to experiment
704 with having a language that is less coupled to the standard prelude, we're
705 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
706 happens to be in scope. Then you can
708 import MyPrelude as Prelude
709 to get the desired effect.
711 At the moment this just happens for
712 * fromInteger, fromRational on literals (in expressions and patterns)
713 * negate (in expressions)
714 * minus (arising from n+k patterns)
717 We store the relevant Name in the HsSyn tree, in
718 * HsIntegral/HsFractional/HsIsString
722 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
723 fromRationalName etc), but the renamer changes this to the appropriate user
724 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
726 We treat the orignal (standard) names as free-vars too, because the type checker
727 checks the type of the user thing against the type of the standard thing.
730 lookupSyntaxName :: Name -- The standard name
731 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
732 lookupSyntaxName std_name
733 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
734 if implicit_prelude then normal_case
736 -- Get the similarly named thing from the local environment
737 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
738 returnM (HsVar usr_name, unitFV usr_name)
740 normal_case = returnM (HsVar std_name, emptyFVs)
742 lookupSyntaxTable :: [Name] -- Standard names
743 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
744 lookupSyntaxTable std_names
745 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
746 if implicit_prelude then normal_case
748 -- Get the similarly named thing from the local environment
749 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
751 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
753 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
757 %*********************************************************
761 %*********************************************************
764 newLocalsRn :: [Located RdrName] -> RnM [Name]
765 newLocalsRn rdr_names_w_loc
766 = newUniqueSupply `thenM` \ us ->
767 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
769 mk (L loc rdr_name) uniq
770 | Just name <- isExact_maybe rdr_name = name
771 -- This happens in code generated by Template Haskell
772 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
773 -- We only bind unqualified names here
774 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
775 mkInternalName uniq (rdrNameOcc rdr_name) loc
777 ---------------------
778 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
779 checkDupAndShadowedRdrNames doc loc_rdr_names
780 = do { checkDupRdrNames doc loc_rdr_names
782 ; checkShadowedNames doc envs
783 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
785 ---------------------
786 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
790 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
791 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
793 -- Make fresh Names and extend the environment
794 newLocalsRn rdr_names_w_loc `thenM` \names ->
795 bindLocalNames names (enclosed_scope names)
797 bindLocalNames :: [Name] -> RnM a -> RnM a
798 bindLocalNames names enclosed_scope
799 = getLocalRdrEnv `thenM` \ name_env ->
800 setLocalRdrEnv (extendLocalRdrEnv name_env names)
803 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
804 bindLocalNamesFV names enclosed_scope
805 = do { (result, fvs) <- bindLocalNames names enclosed_scope
806 ; returnM (result, delListFromNameSet fvs names) }
809 -------------------------------------
810 -- binLocalsFVRn is the same as bindLocalsRn
811 -- except that it deals with free vars
812 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
813 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
814 bindLocatedLocalsFV doc rdr_names enclosed_scope
815 = bindLocatedLocalsRn doc rdr_names $ \ names ->
816 enclosed_scope names `thenM` \ (thing, fvs) ->
817 returnM (thing, delListFromNameSet fvs names)
819 -------------------------------------
820 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
821 -> ([LHsTyVarBndr Name] -> RnM a)
823 -- Haskell-98 binding of type variables; e.g. within a data type decl
824 bindTyVarsRn doc_str tyvar_names enclosed_scope
826 located_tyvars = hsLTyVarLocNames tyvar_names
828 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
829 enclosed_scope (zipWith replace tyvar_names names)
831 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
833 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
834 -- Find the type variables in the pattern type
835 -- signatures that must be brought into scope
836 bindPatSigTyVars tys thing_inside
837 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
838 ; if not scoped_tyvars then
841 do { name_env <- getLocalRdrEnv
842 ; let locd_tvs = [ tv | ty <- tys
843 , tv <- extractHsTyRdrTyVars ty
844 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
845 nubbed_tvs = nubBy eqLocated locd_tvs
846 -- The 'nub' is important. For example:
847 -- f (x :: t) (y :: t) = ....
848 -- We don't want to complain about binding t twice!
850 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
852 doc_sig = text "In a pattern type-signature"
854 bindPatSigTyVarsFV :: [LHsType RdrName]
857 bindPatSigTyVarsFV tys thing_inside
858 = bindPatSigTyVars tys $ \ tvs ->
859 thing_inside `thenM` \ (result,fvs) ->
860 returnM (result, fvs `delListFromNameSet` tvs)
862 bindSigTyVarsFV :: [Name]
865 bindSigTyVarsFV tvs thing_inside
866 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
867 ; if not scoped_tyvars then
870 bindLocalNamesFV tvs thing_inside }
872 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
873 -- This function is used only in rnSourceDecl on InstDecl
874 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
876 -------------------------------------
877 checkDupRdrNames :: SDoc
880 checkDupRdrNames doc_str rdr_names_w_loc
881 = -- Check for duplicated names in a binding group
882 mappM_ (dupNamesErr getLoc doc_str) dups
884 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
886 checkDupNames :: SDoc
889 checkDupNames doc_str names
890 = -- Check for duplicated names in a binding group
891 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
893 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
895 -------------------------------------
896 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
897 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
898 = ifOptM Opt_WarnNameShadowing $
899 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
900 ; mappM_ check_shadow loc_rdr_names }
902 check_shadow (loc, occ)
903 | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
904 | otherwise = do { gres' <- filterM is_shadowed_gre gres
905 ; complain (map pprNameProvenance gres') }
907 complain [] = return ()
908 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
909 mb_local = lookupLocalRdrOcc local_env occ
910 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
911 -- Make an Unqualified RdrName and look that up, so that
912 -- we don't find any GREs that are in scope qualified-only
914 is_shadowed_gre :: GlobalRdrElt -> RnM Bool
915 -- Returns False for record selectors that are shadowed, when
916 -- punning or wild-cards are on (cf Trac #2723)
917 is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
918 = do { dflags <- getDOpts
919 ; if (dopt Opt_RecordPuns dflags || dopt Opt_RecordWildCards dflags)
920 then do { is_fld <- is_rec_fld gre; return (not is_fld) }
922 is_shadowed_gre _other = return True
924 is_rec_fld gre -- Return True for record selector ids
925 | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
926 ; return (gre_name gre `elemNameSet` fld_set) }
927 | otherwise = do { sel_id <- tcLookupField (gre_name gre)
928 ; return (isRecordSelector sel_id) }
932 %************************************************************************
934 \subsection{Free variable manipulation}
936 %************************************************************************
940 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
941 mapFvRn f xs = do stuff <- mappM f xs
943 (ys, fvs_s) -> returnM (ys, plusFVs fvs_s)
945 -- because some of the rename functions are CPSed:
946 -- maps the function across the list from left to right;
947 -- collects all the free vars into one set
948 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
949 -> [a] -> ([b] -> RnM c) -> RnM c
951 mapFvRnCPS _ [] cont = cont []
952 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
953 mapFvRnCPS f xs $ \ xs' ->
958 %************************************************************************
960 \subsection{Envt utility functions}
962 %************************************************************************
965 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
966 warnUnusedModules mods
967 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
969 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
970 mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
971 <+> text "is imported, but nothing from it is used,",
972 nest 2 (ptext (sLit "except perhaps instances visible in")
974 ptext (sLit "To suppress this warning, use:")
975 <+> ptext (sLit "import") <+> ppr m <> parens empty ]
978 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
979 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
980 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
982 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
983 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
984 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
986 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
987 check_unused flag bound_names used_names
988 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
990 -------------------------
992 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
994 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
996 warnUnusedLocals :: [Name] -> RnM ()
997 warnUnusedLocals names
998 = warnUnusedBinds [(n,LocalDef) | n<-names]
1000 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1001 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
1002 where reportable (name,_)
1003 | isWiredInName name = False -- Don't report unused wired-in names
1004 -- Otherwise we get a zillion warnings
1006 | otherwise = reportIfUnused (nameOccName name)
1008 -------------------------
1010 warnUnusedName :: (Name, Provenance) -> RnM ()
1011 warnUnusedName (name, LocalDef)
1012 = addUnusedWarning name (nameSrcSpan name)
1013 (ptext (sLit "Defined but not used"))
1015 warnUnusedName (name, Imported is)
1018 warn spec = addUnusedWarning name span msg
1020 span = importSpecLoc spec
1021 pp_mod = quotes (ppr (importSpecModule spec))
1022 msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1024 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1025 addUnusedWarning name span msg
1028 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1029 <+> quotes (ppr name)]
1033 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1034 addNameClashErrRn rdr_name names
1035 = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1036 ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1039 msg1 = ptext (sLit "either") <+> mk_ref np1
1040 msgs = [ptext (sLit " or") <+> mk_ref np | np <- nps]
1041 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1043 shadowedNameWarn :: SDoc -> OccName -> [SDoc] -> SDoc
1044 shadowedNameWarn doc occ shadowed_locs
1045 = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1046 <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1047 nest 2 (vcat shadowed_locs)]
1050 unknownNameErr :: RdrName -> SDoc
1051 unknownNameErr rdr_name
1052 = vcat [ hang (ptext (sLit "Not in scope:"))
1053 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1054 <+> quotes (ppr rdr_name))
1057 extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1060 perhapsForallMsg :: SDoc
1062 = vcat [ ptext (sLit "Perhaps you intended to use -XRankNTypes or similar flag")
1063 , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1065 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1066 unknownSubordinateErr doc op -- Doc is "method of class" or
1067 -- "field of constructor"
1068 = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1070 badOrigBinding :: RdrName -> SDoc
1072 = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1073 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1075 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1076 dupNamesErr get_loc descriptor names
1077 = addErrAt big_loc $
1078 vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1079 locations, descriptor]
1081 locs = map get_loc names
1082 big_loc = foldr1 combineSrcSpans locs
1083 one_line = isOneLineSpan big_loc
1084 locations | one_line = empty
1085 | otherwise = ptext (sLit "Bound at:") <+>
1086 vcat (map ppr (sortLe (<=) locs))
1088 badQualBndrErr :: RdrName -> SDoc
1089 badQualBndrErr rdr_name
1090 = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name