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, lookupGlobalOccRn,
12 lookupLocalDataTcNames, lookupSrcOcc_maybe,
14 lookupFixityRn, lookupTyFixityRn,
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, 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
304 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
305 -- NB: qualified names are rejected by the parser
306 lookupImportedName rdr_name
308 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
309 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
311 -- Looking up family names in type instances is a subtle affair. The family
312 -- may be imported, in which case we need to lookup the occurence of a global
313 -- name. Alternatively, the family may be in the same binding group (and in
314 -- fact in a declaration processed later), and we need to create a new top
317 -- So, also this is strictly speaking an occurence, we cannot raise an error
318 -- message yet for instances without a family declaration. This will happen
319 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
321 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
322 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
323 = do { mb_gre <- lookupGreRn_maybe rdr_name
325 Just gre -> returnM (gre_name gre)
326 Nothing -> newTopSrcBinder mod lrdr_name }
328 --------------------------------------------------
330 --------------------------------------------------
332 getLookupOccRn :: RnM (Name -> Maybe Name)
334 = getLocalRdrEnv `thenM` \ local_env ->
335 return (lookupLocalRdrOcc local_env . nameOccName)
337 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
338 lookupLocatedOccRn = wrapLocM lookupOccRn
340 -- lookupOccRn looks up an occurrence of a RdrName
341 lookupOccRn :: RdrName -> RnM Name
343 = getLocalRdrEnv `thenM` \ local_env ->
344 case lookupLocalRdrEnv local_env rdr_name of
345 Just name -> returnM name
346 Nothing -> lookupGlobalOccRn rdr_name
348 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
349 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
351 lookupGlobalOccRn :: RdrName -> RnM Name
352 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
353 -- environment. It's used only for
354 -- record field names
355 -- class op names in class and instance decls
357 lookupGlobalOccRn rdr_name
358 | not (isSrcRdrName rdr_name)
359 = lookupImportedName rdr_name
363 -- First look up the name in the normal environment.
364 mb_gre <- lookupGreRn_maybe rdr_name
366 Just gre -> returnM (gre_name gre) ;
369 -- We allow qualified names on the command line to refer to
370 -- *any* name exported by any module in scope, just as if
371 -- there was an "import qualified M" declaration for every
373 allow_qual <- doptM Opt_ImplicitImportQualified
375 -- This test is not expensive,
376 -- and only happens for failed lookups
377 if isQual rdr_name && allow_qual && mod == iNTERACTIVE
378 then lookupQualifiedName rdr_name
379 else unboundName rdr_name
382 lookupImportedName :: RdrName -> TcRnIf m n Name
383 -- Lookup the occurrence of an imported name
384 -- The RdrName is *always* qualified or Exact
385 -- Treat it as an original name, and conjure up the Name
386 -- Usually it's Exact or Orig, but it can be Qual if it
387 -- comes from an hi-boot file. (This minor infelicity is
388 -- just to reduce duplication in the parser.)
389 lookupImportedName rdr_name
390 | Just n <- isExact_maybe rdr_name
391 -- This happens in derived code
394 -- Always Orig, even when reading a .hi-boot file
395 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
396 = lookupOrig rdr_mod rdr_occ
399 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
401 unboundName :: RdrName -> RnM Name
403 = do { addErr (unknownNameErr rdr_name)
404 ; env <- getGlobalRdrEnv;
405 ; traceRn (vcat [unknownNameErr rdr_name,
406 ptext (sLit "Global envt is:"),
407 nest 3 (pprGlobalRdrEnv env)])
408 ; returnM (mkUnboundName rdr_name) }
410 --------------------------------------------------
411 -- Lookup in the Global RdrEnv of the module
412 --------------------------------------------------
414 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
415 -- No filter function; does not report an error on failure
416 lookupSrcOcc_maybe rdr_name
417 = do { mb_gre <- lookupGreRn_maybe rdr_name
419 Nothing -> returnM Nothing
420 Just gre -> returnM (Just (gre_name gre)) }
422 -------------------------
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
455 [] -> returnM Nothing
456 [gre] -> returnM (Just gre)
457 gres -> do { addNameClashErrRn rdr_name gres
458 ; returnM (Just (head gres)) } }
460 ------------------------------
462 ------------------------------
464 -- A qualified name on the command line can refer to any module at all: we
465 -- try to load the interface if we don't already have it.
466 lookupQualifiedName :: RdrName -> RnM Name
467 lookupQualifiedName rdr_name
468 | Just (mod,occ) <- isQual_maybe rdr_name
469 -- Note: we want to behave as we would for a source file import here,
470 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
471 = loadSrcInterface doc mod False Nothing `thenM` \ iface ->
474 (mod,avails) <- mi_exports iface,
476 name <- availNames avail,
478 ((mod,occ):ns) -> ASSERT (null ns)
480 _ -> unboundName rdr_name
483 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
485 doc = ptext (sLit "Need to find") <+> ppr rdr_name
488 lookupSigOccRn is used for type signatures and pragmas
494 It's clear that the 'f' in the signature must refer to A.f
495 The Haskell98 report does not stipulate this, but it will!
496 So we must treat the 'f' in the signature in the same way
497 as the binding occurrence of 'f', using lookupBndrRn
499 However, consider this case:
503 We don't want to say 'f' is out of scope; instead, we want to
504 return the imported 'f', so that later on the reanamer will
505 correctly report "misplaced type sig".
508 lookupSigOccRn :: Maybe NameSet -- Just ns => source file; these are the binders
510 -- Nothing => hs-boot file; signatures without
511 -- binders are expected
513 -> Located RdrName -> RnM (Located Name)
514 lookupSigOccRn mb_bound_names sig
515 = wrapLocM $ \ rdr_name ->
516 do { mb_name <- lookupBindGroupOcc mb_bound_names (hsSigDoc sig) rdr_name
518 Left err -> do { addErr err; return (mkUnboundName rdr_name) }
519 Right name -> return name }
521 lookupBindGroupOcc :: Maybe NameSet -- Just ns => source file; these are the binders
523 -- Nothing => hs-boot file; signatures without
524 -- binders are expected
526 -> RdrName -> RnM (Either Message Name)
527 -- Looks up the RdrName, expecting it to resolve to one of the
528 -- bound names passed in. If not, return an appropriate error message
529 lookupBindGroupOcc mb_bound_names what rdr_name
530 = do { local_env <- getLocalRdrEnv
531 ; case lookupLocalRdrEnv local_env rdr_name of
532 Just n -> check_local_name n
533 Nothing -> do -- Not defined in a nested scope
535 { env <- getGlobalRdrEnv
536 ; let gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)
537 ; case (filter isLocalGRE gres) of
538 (gre:_) -> check_local_name (gre_name gre)
539 -- If there is more than one local GRE for the
540 -- same OccName, that will be reported separately
541 [] | null gres -> bale_out_with empty
542 | otherwise -> bale_out_with import_msg
545 check_local_name name -- The name is in scope, and not imported
546 = case mb_bound_names of
547 Just bound_names | not (name `elemNameSet` bound_names)
548 -> bale_out_with local_msg
549 _other -> return (Right name)
552 = return (Left (sep [ ptext (sLit "The") <+> what
553 <+> ptext (sLit "for") <+> quotes (ppr rdr_name)
554 , nest 2 $ ptext (sLit "lacks an accompanying binding")]
557 local_msg = parens $ ptext (sLit "The") <+> what <+> ptext (sLit "must be given where")
558 <+> quotes (ppr rdr_name) <+> ptext (sLit "is declared")
560 import_msg = parens $ ptext (sLit "You cannot give a") <+> what
561 <+> ptext (sLit "for an imported value")
564 lookupLocalDataTcNames :: NameSet -> SDoc -> RdrName -> RnM [Name]
565 -- GHC extension: look up both the tycon and data con
566 -- for con-like things
567 -- Complain if neither is in scope
568 lookupLocalDataTcNames bound_names what rdr_name
569 | Just n <- isExact_maybe rdr_name
570 -- Special case for (:), which doesn't get into the GlobalRdrEnv
571 = return [n] -- For this we don't need to try the tycon too
573 = do { mb_gres <- mapM (lookupBindGroupOcc (Just bound_names) what)
574 (dataTcOccs rdr_name)
575 ; let (errs, names) = splitEithers mb_gres
576 ; when (null names) (addErr (head errs)) -- Bleat about one only
579 dataTcOccs :: RdrName -> [RdrName]
580 -- If the input is a data constructor, return both it and a type
581 -- constructor. This is useful when we aren't sure which we are
584 | Just n <- isExact_maybe rdr_name -- Ghastly special case
585 , n `hasKey` consDataConKey = [rdr_name] -- see note below
586 | isDataOcc occ = [rdr_name, rdr_name_tc]
587 | otherwise = [rdr_name]
589 occ = rdrNameOcc rdr_name
590 rdr_name_tc = setRdrNameSpace rdr_name tcName
592 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
593 -- and setRdrNameSpace generates an Orig, which is fine
594 -- But it's not fine for (:), because there *is* no corresponding type
595 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
596 -- appear to be in scope (because Orig's simply allocate a new name-cache
597 -- entry) and then we get an error when we use dataTcOccs in
598 -- TcRnDriver.tcRnGetInfo. Large sigh.
602 %*********************************************************
606 %*********************************************************
609 --------------------------------
610 type FastStringEnv a = UniqFM a -- Keyed by FastString
613 emptyFsEnv :: FastStringEnv a
614 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
615 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
617 emptyFsEnv = emptyUFM
618 lookupFsEnv = lookupUFM
619 extendFsEnv = addToUFM
621 --------------------------------
622 type MiniFixityEnv = FastStringEnv (Located Fixity)
623 -- Mini fixity env for the names we're about
624 -- to bind, in a single binding group
626 -- It is keyed by the *FastString*, not the *OccName*, because
627 -- the single fixity decl infix 3 T
628 -- affects both the data constructor T and the type constrctor T
630 -- We keep the location so that if we find
631 -- a duplicate, we can report it sensibly
633 --------------------------------
634 -- Used for nested fixity decls to bind names along with their fixities.
635 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
636 -- Also check for unused binders
637 bindLocalNamesFV_WithFixities :: [Name]
639 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
640 bindLocalNamesFV_WithFixities names fixities thing_inside
641 = bindLocalNamesFV names $
642 extendFixityEnv boundFixities $
645 -- find the names that have fixity decls
646 boundFixities = foldr
648 -- check whether this name has a fixity decl
649 case lookupFsEnv fixities (occNameFS (nameOccName name)) of
650 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
651 Nothing -> acc) [] names
652 -- bind the names; extend the fixity env; do the thing inside
655 --------------------------------
656 lookupFixity is a bit strange.
658 * Nested local fixity decls are put in the local fixity env, which we
659 find with getFixtyEnv
661 * Imported fixities are found in the HIT or PIT
663 * Top-level fixity decls in this module may be for Names that are
664 either Global (constructors, class operations)
665 or Local/Exported (everything else)
666 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
667 We put them all in the local fixity environment
670 lookupFixityRn :: Name -> RnM Fixity
672 = getModule `thenM` \ this_mod ->
673 if nameIsLocalOrFrom this_mod name
674 then do -- It's defined in this module
675 local_fix_env <- getFixityEnv
676 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
677 vcat [ppr name, ppr local_fix_env])
678 return $ lookupFixity local_fix_env name
679 else -- It's imported
680 -- For imported names, we have to get their fixities by doing a
681 -- loadInterfaceForName, and consulting the Ifaces that comes back
682 -- from that, because the interface file for the Name might not
683 -- have been loaded yet. Why not? Suppose you import module A,
684 -- which exports a function 'f', thus;
685 -- module CurrentModule where
687 -- module A( f ) where
689 -- Then B isn't loaded right away (after all, it's possible that
690 -- nothing from B will be used). When we come across a use of
691 -- 'f', we need to know its fixity, and it's then, and only
692 -- then, that we load B.hi. That is what's happening here.
694 -- loadInterfaceForName will find B.hi even if B is a hidden module,
695 -- and that's what we want.
696 loadInterfaceForName doc name `thenM` \ iface -> do {
697 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
698 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
699 returnM (mi_fix_fn iface (nameOccName name))
702 doc = ptext (sLit "Checking fixity for") <+> ppr name
705 lookupTyFixityRn :: Located Name -> RnM Fixity
706 lookupTyFixityRn (L _ n) = lookupFixityRn n
710 %************************************************************************
713 Dealing with rebindable syntax is driven by the
714 Opt_NoImplicitPrelude dynamic flag.
716 In "deriving" code we don't want to use rebindable syntax
717 so we switch off the flag locally
720 %************************************************************************
722 Haskell 98 says that when you say "3" you get the "fromInteger" from the
723 Standard Prelude, regardless of what is in scope. However, to experiment
724 with having a language that is less coupled to the standard prelude, we're
725 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
726 happens to be in scope. Then you can
728 import MyPrelude as Prelude
729 to get the desired effect.
731 At the moment this just happens for
732 * fromInteger, fromRational on literals (in expressions and patterns)
733 * negate (in expressions)
734 * minus (arising from n+k patterns)
737 We store the relevant Name in the HsSyn tree, in
738 * HsIntegral/HsFractional/HsIsString
742 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
743 fromRationalName etc), but the renamer changes this to the appropriate user
744 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
746 We treat the orignal (standard) names as free-vars too, because the type checker
747 checks the type of the user thing against the type of the standard thing.
750 lookupSyntaxName :: Name -- The standard name
751 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
752 lookupSyntaxName std_name
753 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
754 if implicit_prelude then normal_case
756 -- Get the similarly named thing from the local environment
757 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
758 returnM (HsVar usr_name, unitFV usr_name)
760 normal_case = returnM (HsVar std_name, emptyFVs)
762 lookupSyntaxTable :: [Name] -- Standard names
763 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
764 lookupSyntaxTable std_names
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 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
771 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
773 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
777 %*********************************************************
781 %*********************************************************
784 newLocalsRn :: [Located RdrName] -> RnM [Name]
785 newLocalsRn rdr_names_w_loc
786 = newUniqueSupply `thenM` \ us ->
787 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
789 mk (L loc rdr_name) uniq
790 | Just name <- isExact_maybe rdr_name = name
791 -- This happens in code generated by Template Haskell
792 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
793 -- We only bind unqualified names here
794 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
795 mkInternalName uniq (rdrNameOcc rdr_name) loc
797 ---------------------
798 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
799 checkDupAndShadowedRdrNames doc loc_rdr_names
800 = do { checkDupRdrNames doc loc_rdr_names
802 ; checkShadowedNames doc envs
803 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
805 ---------------------
806 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
810 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
811 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
813 -- Make fresh Names and extend the environment
814 newLocalsRn rdr_names_w_loc `thenM` \names ->
815 bindLocalNames names (enclosed_scope names)
817 bindLocalNames :: [Name] -> RnM a -> RnM a
818 bindLocalNames names enclosed_scope
819 = getLocalRdrEnv `thenM` \ name_env ->
820 setLocalRdrEnv (extendLocalRdrEnv name_env names)
823 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
824 bindLocalNamesFV names enclosed_scope
825 = do { (result, fvs) <- bindLocalNames names enclosed_scope
826 ; returnM (result, delListFromNameSet fvs names) }
829 -------------------------------------
830 -- binLocalsFVRn is the same as bindLocalsRn
831 -- except that it deals with free vars
832 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
833 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
834 bindLocatedLocalsFV doc rdr_names enclosed_scope
835 = bindLocatedLocalsRn doc rdr_names $ \ names ->
836 enclosed_scope names `thenM` \ (thing, fvs) ->
837 returnM (thing, delListFromNameSet fvs names)
839 -------------------------------------
840 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
841 -> ([LHsTyVarBndr Name] -> RnM a)
843 -- Haskell-98 binding of type variables; e.g. within a data type decl
844 bindTyVarsRn doc_str tyvar_names enclosed_scope
846 located_tyvars = hsLTyVarLocNames tyvar_names
848 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
849 enclosed_scope (zipWith replace tyvar_names names)
851 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
853 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
854 -- Find the type variables in the pattern type
855 -- signatures that must be brought into scope
856 bindPatSigTyVars tys thing_inside
857 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
858 ; if not scoped_tyvars then
861 do { name_env <- getLocalRdrEnv
862 ; let locd_tvs = [ tv | ty <- tys
863 , tv <- extractHsTyRdrTyVars ty
864 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
865 nubbed_tvs = nubBy eqLocated locd_tvs
866 -- The 'nub' is important. For example:
867 -- f (x :: t) (y :: t) = ....
868 -- We don't want to complain about binding t twice!
870 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
872 doc_sig = text "In a pattern type-signature"
874 bindPatSigTyVarsFV :: [LHsType RdrName]
877 bindPatSigTyVarsFV tys thing_inside
878 = bindPatSigTyVars tys $ \ tvs ->
879 thing_inside `thenM` \ (result,fvs) ->
880 returnM (result, fvs `delListFromNameSet` tvs)
882 bindSigTyVarsFV :: [Name]
885 bindSigTyVarsFV tvs thing_inside
886 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
887 ; if not scoped_tyvars then
890 bindLocalNamesFV tvs thing_inside }
892 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
893 -- This function is used only in rnSourceDecl on InstDecl
894 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
896 -------------------------------------
897 checkDupRdrNames :: SDoc
900 checkDupRdrNames doc_str rdr_names_w_loc
901 = -- Check for duplicated names in a binding group
902 mappM_ (dupNamesErr getLoc doc_str) dups
904 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
906 checkDupNames :: SDoc
909 checkDupNames doc_str names
910 = -- Check for duplicated names in a binding group
911 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
913 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
915 -------------------------------------
916 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
917 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
918 = ifOptM Opt_WarnNameShadowing $
919 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
920 ; mappM_ check_shadow loc_rdr_names }
922 check_shadow (loc, occ)
923 | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
924 | otherwise = do { gres' <- filterM is_shadowed_gre gres
925 ; complain (map pprNameProvenance gres') }
927 complain [] = return ()
928 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
929 mb_local = lookupLocalRdrOcc local_env occ
930 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
931 -- Make an Unqualified RdrName and look that up, so that
932 -- we don't find any GREs that are in scope qualified-only
934 is_shadowed_gre :: GlobalRdrElt -> RnM Bool
935 -- Returns False for record selectors that are shadowed, when
936 -- punning or wild-cards are on (cf Trac #2723)
937 is_shadowed_gre gre@(GRE { gre_par = ParentIs _ })
938 = do { dflags <- getDOpts
939 ; if (dopt Opt_RecordPuns dflags || dopt Opt_RecordWildCards dflags)
940 then do { is_fld <- is_rec_fld gre; return (not is_fld) }
942 is_shadowed_gre _other = return True
944 is_rec_fld gre -- Return True for record selector ids
945 | isLocalGRE gre = do { RecFields _ fld_set <- getRecFieldEnv
946 ; return (gre_name gre `elemNameSet` fld_set) }
947 | otherwise = do { sel_id <- tcLookupField (gre_name gre)
948 ; return (isRecordSelector sel_id) }
952 %************************************************************************
954 \subsection{Free variable manipulation}
956 %************************************************************************
960 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
961 mapFvRn f xs = do stuff <- mappM f xs
963 (ys, fvs_s) -> returnM (ys, plusFVs fvs_s)
965 -- because some of the rename functions are CPSed:
966 -- maps the function across the list from left to right;
967 -- collects all the free vars into one set
968 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
969 -> [a] -> ([b] -> RnM c) -> RnM c
971 mapFvRnCPS _ [] cont = cont []
972 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
973 mapFvRnCPS f xs $ \ xs' ->
978 %************************************************************************
980 \subsection{Envt utility functions}
982 %************************************************************************
985 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
986 warnUnusedModules mods
987 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
989 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
990 mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
991 <+> text "is imported, but nothing from it is used,",
992 nest 2 (ptext (sLit "except perhaps instances visible in")
994 ptext (sLit "To suppress this warning, use:")
995 <+> ptext (sLit "import") <+> ppr m <> parens empty ]
998 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
999 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
1000 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
1002 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
1003 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
1004 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
1006 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
1007 check_unused flag bound_names used_names
1008 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
1010 -------------------------
1012 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
1014 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
1016 warnUnusedLocals :: [Name] -> RnM ()
1017 warnUnusedLocals names
1018 = warnUnusedBinds [(n,LocalDef) | n<-names]
1020 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
1021 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
1022 where reportable (name,_)
1023 | isWiredInName name = False -- Don't report unused wired-in names
1024 -- Otherwise we get a zillion warnings
1026 | otherwise = reportIfUnused (nameOccName name)
1028 -------------------------
1030 warnUnusedName :: (Name, Provenance) -> RnM ()
1031 warnUnusedName (name, LocalDef)
1032 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
1033 (ptext (sLit "Defined but not used"))
1035 warnUnusedName (name, Imported is)
1038 warn spec = addUnusedWarning name span msg
1040 span = importSpecLoc spec
1041 pp_mod = quotes (ppr (importSpecModule spec))
1042 msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
1044 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
1045 addUnusedWarning name span msg
1048 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1049 <+> quotes (ppr name)]
1053 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
1054 addNameClashErrRn rdr_name names
1055 = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
1056 ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
1059 msg1 = ptext (sLit "either") <+> mk_ref np1
1060 msgs = [ptext (sLit " or") <+> mk_ref np | np <- nps]
1061 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1063 shadowedNameWarn :: SDoc -> OccName -> [SDoc] -> SDoc
1064 shadowedNameWarn doc occ shadowed_locs
1065 = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
1066 <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
1067 nest 2 (vcat shadowed_locs)]
1070 unknownNameErr :: RdrName -> SDoc
1071 unknownNameErr rdr_name
1072 = vcat [ hang (ptext (sLit "Not in scope:"))
1073 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1074 <+> quotes (ppr rdr_name))
1077 extra | rdr_name == forall_tv_RDR = perhapsForallMsg
1080 perhapsForallMsg :: SDoc
1082 = vcat [ ptext (sLit "Perhaps you intended to use -XRankNTypes or similar flag")
1083 , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
1085 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
1086 unknownSubordinateErr doc op -- Doc is "method of class" or
1087 -- "field of constructor"
1088 = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1090 badOrigBinding :: RdrName -> SDoc
1092 = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1093 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1095 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1096 dupNamesErr get_loc descriptor names
1097 = addErrAt big_loc $
1098 vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1099 locations, descriptor]
1101 locs = map get_loc names
1102 big_loc = foldr1 combineSrcSpans locs
1103 one_line = isOneLineSpan big_loc
1104 locations | one_line = empty
1105 | otherwise = ptext (sLit "Bound at:") <+>
1106 vcat (map ppr (sortLe (<=) locs))
1108 badQualBndrErr :: RdrName -> SDoc
1109 badQualBndrErr rdr_name
1110 = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name