2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
4 \section[RnEnv]{Environment manipulation for the renamer monad}
8 newTopSrcBinder, lookupFamInstDeclBndr,
9 lookupLocatedBndrRn, lookupBndrRn, lookupBndrRn_maybe,
10 lookupLocatedTopBndrRn, lookupTopBndrRn,
11 lookupLocatedOccRn, lookupOccRn,
12 lookupLocatedGlobalOccRn, lookupGlobalOccRn,
13 lookupLocalDataTcNames, lookupSrcOcc_maybe,
14 lookupFixityRn, lookupTyFixityRn,
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 )
46 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
47 nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
51 import DataCon ( dataConFieldLabels )
53 import Module ( Module, ModuleName )
54 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE,
55 consDataConKey, hasKey, forall_tv_RDR )
57 import BasicTypes ( IPName, mapIPName, Fixity )
62 import ListSetOps ( removeDups )
71 thenM :: Monad a => a b -> (b -> a c) -> a c
74 thenM_ :: Monad a => a b -> a c -> a c
77 returnM :: Monad m => a -> m a
80 mappM :: (Monad m) => (a -> m b) -> [a] -> m [b]
83 mappM_ :: (Monad m) => (a -> m b) -> [a] -> m ()
86 checkM :: Monad m => Bool -> m () -> m ()
90 %*********************************************************
94 %*********************************************************
97 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
98 newTopSrcBinder this_mod (L loc rdr_name)
99 | Just name <- isExact_maybe rdr_name
100 = -- This is here to catch
101 -- (a) Exact-name binders created by Template Haskell
102 -- (b) The PrelBase defn of (say) [] and similar, for which
103 -- the parser reads the special syntax and returns an Exact RdrName
104 -- We are at a binding site for the name, so check first that it
105 -- the current module is the correct one; otherwise GHC can get
106 -- very confused indeed. This test rejects code like
107 -- data T = (,) Int Int
108 -- unless we are in GHC.Tup
109 ASSERT2( isExternalName name, ppr name )
110 do { checkM (this_mod == nameModule name)
111 (addErrAt loc (badOrigBinding rdr_name))
115 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
116 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
117 (addErrAt loc (badOrigBinding rdr_name))
118 -- When reading External Core we get Orig names as binders,
119 -- but they should agree with the module gotten from the monad
121 -- We can get built-in syntax showing up here too, sadly. If you type
123 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
124 -- uses setRdrNameSpace to make it into a data constructors. At that point
125 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
126 -- Hence the badOrigBinding error message.
128 -- Except for the ":Main.main = ..." definition inserted into
129 -- the Main module; ugh!
131 -- Because of this latter case, we call newGlobalBinder with a module from
132 -- the RdrName, not from the environment. In principle, it'd be fine to
133 -- have an arbitrary mixture of external core definitions in a single module,
134 -- (apart from module-initialisation issues, perhaps).
135 ; newGlobalBinder rdr_mod rdr_occ loc }
136 --TODO, should pass the whole span
139 = do { checkM (not (isQual rdr_name))
140 (addErrAt loc (badQualBndrErr rdr_name))
141 -- Binders should not be qualified; if they are, and with a different
142 -- module name, we we get a confusing "M.T is not in scope" error later
143 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
146 %*********************************************************
148 Source code occurrences
150 %*********************************************************
152 Looking up a name in the RnEnv.
155 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
156 lookupLocatedBndrRn = wrapLocM lookupBndrRn
158 lookupBndrRn :: RdrName -> RnM Name
159 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
162 Nothing -> do traceRn $ text "lookupTopBndrRn"
165 lookupTopBndrRn :: RdrName -> RnM Name
166 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
169 Nothing -> do traceRn $ text "lookupTopBndrRn"
172 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
173 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
174 lookupBndrRn_maybe rdr_name
175 = getLocalRdrEnv `thenM` \ local_env ->
176 case lookupLocalRdrEnv local_env rdr_name of
177 Just name -> returnM (Just name)
178 Nothing -> lookupTopBndrRn_maybe rdr_name
180 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
181 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
183 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
184 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
185 -- and there may be several imported 'f's too, which must not confuse us.
186 -- For example, this is OK:
188 -- infix 9 f -- The 'f' here does not need to be qualified
189 -- f x = x -- Nor here, of course
190 -- So we have to filter out the non-local ones.
192 -- A separate function (importsFromLocalDecls) reports duplicate top level
193 -- decls, so here it's safe just to choose an arbitrary one.
195 -- There should never be a qualified name in a binding position in Haskell,
196 -- but there can be if we have read in an external-Core file.
197 -- The Haskell parser checks for the illegal qualified name in Haskell
198 -- source files, so we don't need to do so here.
200 lookupTopBndrRn_maybe rdr_name
201 | Just name <- isExact_maybe rdr_name
202 = returnM (Just name)
204 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
205 -- This deals with the case of derived bindings, where
206 -- we don't bother to call newTopSrcBinder first
207 -- We assume there is no "parent" name
208 = do { loc <- getSrcSpanM
209 ; n <- newGlobalBinder rdr_mod rdr_occ loc
213 = do { mb_gre <- lookupGreLocalRn rdr_name
215 Nothing -> returnM Nothing
216 Just gre -> returnM (Just $ gre_name gre) }
219 -----------------------------------------------
220 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
221 -- This is called on the method name on the left-hand side of an
222 -- instance declaration binding. eg. instance Functor T where
224 -- ^^^^ called on this
225 -- Regardless of how many unqualified fmaps are in scope, we want
226 -- the one that comes from the Functor class.
228 -- Furthermore, note that we take no account of whether the
229 -- name is only in scope qualified. I.e. even if method op is
230 -- in scope as M.op, we still allow plain 'op' on the LHS of
232 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
234 doc = ptext (sLit "method of class") <+> quotes (ppr cls)
235 is_op (GRE {gre_par = ParentIs n}) = n == cls
238 -----------------------------------------------
239 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
240 -- Used for record construction and pattern matching
241 -- When the -fdisambiguate-record-fields flag is on, take account of the
242 -- constructor name to disambiguate which field to use; it's just the
243 -- same as for instance decls
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 { 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
380 traceRn $ text "lookupGlobalOccRn"
384 lookupImportedName :: RdrName -> TcRnIf m n Name
385 -- Lookup the occurrence of an imported name
386 -- The RdrName is *always* qualified or Exact
387 -- Treat it as an original name, and conjure up the Name
388 -- Usually it's Exact or Orig, but it can be Qual if it
389 -- comes from an hi-boot file. (This minor infelicity is
390 -- just to reduce duplication in the parser.)
391 lookupImportedName rdr_name
392 | Just n <- isExact_maybe rdr_name
393 -- This happens in derived code
396 -- Always Orig, even when reading a .hi-boot file
397 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
398 = lookupOrig rdr_mod rdr_occ
401 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
403 unboundName :: RdrName -> RnM Name
405 = do { addErr (unknownNameErr rdr_name)
406 ; env <- getGlobalRdrEnv;
407 ; traceRn (vcat [unknownNameErr rdr_name,
408 ptext (sLit "Global envt is:"),
409 nest 3 (pprGlobalRdrEnv env)])
410 ; returnM (mkUnboundName rdr_name) }
412 --------------------------------------------------
413 -- Lookup in the Global RdrEnv of the module
414 --------------------------------------------------
416 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
417 -- No filter function; does not report an error on failure
418 lookupSrcOcc_maybe rdr_name
419 = do { mb_gre <- lookupGreRn_maybe rdr_name
421 Nothing -> returnM Nothing
422 Just gre -> returnM (Just (gre_name gre)) }
424 -------------------------
425 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
426 -- Just look up the RdrName in the GlobalRdrEnv
427 lookupGreRn_maybe rdr_name
428 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
430 lookupGreRn :: RdrName -> RnM GlobalRdrElt
431 -- If not found, add error message, and return a fake GRE
433 = do { mb_gre <- lookupGreRn_maybe rdr_name
435 Just gre -> return gre ;
437 { traceRn $ text "lookupGreRn"
438 ; name <- unboundName rdr_name
439 ; return (GRE { gre_name = name, gre_par = NoParent,
440 gre_prov = LocalDef }) }}}
442 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
443 -- Similar, but restricted to locally-defined things
444 lookupGreLocalRn rdr_name
445 = lookupGreRn_help rdr_name lookup_fn
447 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
449 lookupGreRn_help :: RdrName -- Only used in error message
450 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
451 -> RnM (Maybe GlobalRdrElt)
452 -- Checks for exactly one match; reports deprecations
453 -- Returns Nothing, without error, if too few
454 lookupGreRn_help rdr_name lookup
455 = do { env <- getGlobalRdrEnv
457 [] -> returnM Nothing
458 [gre] -> returnM (Just gre)
459 gres -> do { addNameClashErrRn rdr_name gres
460 ; returnM (Just (head gres)) } }
462 ------------------------------
464 ------------------------------
466 -- A qualified name on the command line can refer to any module at all: we
467 -- try to load the interface if we don't already have it.
468 lookupQualifiedName :: RdrName -> RnM Name
469 lookupQualifiedName rdr_name
470 | Just (mod,occ) <- isQual_maybe rdr_name
471 -- Note: we want to behave as we would for a source file import here,
472 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
473 = loadSrcInterface doc mod False Nothing `thenM` \ iface ->
476 (mod,avails) <- mi_exports iface,
478 name <- availNames avail,
480 ((mod,occ):ns) -> ASSERT (null ns)
482 _ -> unboundName rdr_name
485 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
487 doc = ptext (sLit "Need to find") <+> ppr rdr_name
490 %*********************************************************
494 %*********************************************************
497 --------------------------------
498 type FastStringEnv a = UniqFM a -- Keyed by FastString
501 emptyFsEnv :: FastStringEnv a
502 lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
503 extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
505 emptyFsEnv = emptyUFM
506 lookupFsEnv = lookupUFM
507 extendFsEnv = addToUFM
509 --------------------------------
510 type MiniFixityEnv = FastStringEnv (Located Fixity)
511 -- Mini fixity env for the names we're about
512 -- to bind, in a single binding group
514 -- It is keyed by the *FastString*, not the *OccName*, because
515 -- the single fixity decl infix 3 T
516 -- affects both the data constructor T and the type constrctor T
518 -- We keep the location so that if we find
519 -- a duplicate, we can report it sensibly
521 --------------------------------
522 -- Used for nested fixity decls to bind names along with their fixities.
523 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
524 -- Also check for unused binders
525 bindLocalNamesFV_WithFixities :: [Name]
527 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
528 bindLocalNamesFV_WithFixities names fixities thing_inside
529 = bindLocalNamesFV names $
530 extendFixityEnv boundFixities $
533 -- find the names that have fixity decls
534 boundFixities = foldr
536 -- check whether this name has a fixity decl
537 case lookupFsEnv fixities (occNameFS (nameOccName name)) of
538 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
539 Nothing -> acc) [] names
540 -- bind the names; extend the fixity env; do the thing inside
543 --------------------------------
544 lookupFixity is a bit strange.
546 * Nested local fixity decls are put in the local fixity env, which we
547 find with getFixtyEnv
549 * Imported fixities are found in the HIT or PIT
551 * Top-level fixity decls in this module may be for Names that are
552 either Global (constructors, class operations)
553 or Local/Exported (everything else)
554 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
555 We put them all in the local fixity environment
558 lookupFixityRn :: Name -> RnM Fixity
560 = getModule `thenM` \ this_mod ->
561 if nameIsLocalOrFrom this_mod name
562 then do -- It's defined in this module
563 local_fix_env <- getFixityEnv
564 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
565 vcat [ppr name, ppr local_fix_env])
566 return $ lookupFixity local_fix_env name
567 else -- It's imported
568 -- For imported names, we have to get their fixities by doing a
569 -- loadInterfaceForName, and consulting the Ifaces that comes back
570 -- from that, because the interface file for the Name might not
571 -- have been loaded yet. Why not? Suppose you import module A,
572 -- which exports a function 'f', thus;
573 -- module CurrentModule where
575 -- module A( f ) where
577 -- Then B isn't loaded right away (after all, it's possible that
578 -- nothing from B will be used). When we come across a use of
579 -- 'f', we need to know its fixity, and it's then, and only
580 -- then, that we load B.hi. That is what's happening here.
582 -- loadInterfaceForName will find B.hi even if B is a hidden module,
583 -- and that's what we want.
584 loadInterfaceForName doc name `thenM` \ iface -> do {
585 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
586 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
587 returnM (mi_fix_fn iface (nameOccName name))
590 doc = ptext (sLit "Checking fixity for") <+> ppr name
593 lookupTyFixityRn :: Located Name -> RnM Fixity
594 lookupTyFixityRn (L _ n) = lookupFixityRn n
597 lookupLocalDataTcNames :: RdrName -> RnM [Name]
598 -- GHC extension: look up both the tycon and data con
599 -- for con-like things
600 -- Complain if neither is in scope
601 lookupLocalDataTcNames rdr_name
602 | Just n <- isExact_maybe rdr_name
603 -- Special case for (:), which doesn't get into the GlobalRdrEnv
604 = return [n] -- For this we don't need to try the tycon too
606 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
607 ; case [gre_name gre | Just gre <- mb_gres] of
609 -- run for error reporting
610 ; unboundName rdr_name
612 names -> return names
615 dataTcOccs :: RdrName -> [RdrName]
616 -- If the input is a data constructor, return both it and a type
617 -- constructor. This is useful when we aren't sure which we are
620 | Just n <- isExact_maybe rdr_name -- Ghastly special case
621 , n `hasKey` consDataConKey = [rdr_name] -- see note below
622 | isDataOcc occ = [rdr_name_tc, rdr_name]
623 | otherwise = [rdr_name]
625 occ = rdrNameOcc rdr_name
626 rdr_name_tc = setRdrNameSpace rdr_name tcName
628 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
629 -- and setRdrNameSpace generates an Orig, which is fine
630 -- But it's not fine for (:), because there *is* no corresponding type
631 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
632 -- appear to be in scope (because Orig's simply allocate a new name-cache
633 -- entry) and then we get an error when we use dataTcOccs in
634 -- TcRnDriver.tcRnGetInfo. Large sigh.
637 %************************************************************************
640 Dealing with rebindable syntax is driven by the
641 Opt_NoImplicitPrelude dynamic flag.
643 In "deriving" code we don't want to use rebindable syntax
644 so we switch off the flag locally
647 %************************************************************************
649 Haskell 98 says that when you say "3" you get the "fromInteger" from the
650 Standard Prelude, regardless of what is in scope. However, to experiment
651 with having a language that is less coupled to the standard prelude, we're
652 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
653 happens to be in scope. Then you can
655 import MyPrelude as Prelude
656 to get the desired effect.
658 At the moment this just happens for
659 * fromInteger, fromRational on literals (in expressions and patterns)
660 * negate (in expressions)
661 * minus (arising from n+k patterns)
664 We store the relevant Name in the HsSyn tree, in
665 * HsIntegral/HsFractional/HsIsString
669 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
670 fromRationalName etc), but the renamer changes this to the appropriate user
671 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
673 We treat the orignal (standard) names as free-vars too, because the type checker
674 checks the type of the user thing against the type of the standard thing.
677 lookupSyntaxName :: Name -- The standard name
678 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
679 lookupSyntaxName std_name
680 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
681 if implicit_prelude then normal_case
683 -- Get the similarly named thing from the local environment
684 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
685 returnM (HsVar usr_name, unitFV usr_name)
687 normal_case = returnM (HsVar std_name, emptyFVs)
689 lookupSyntaxTable :: [Name] -- Standard names
690 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
691 lookupSyntaxTable std_names
692 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
693 if implicit_prelude then normal_case
695 -- Get the similarly named thing from the local environment
696 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
698 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
700 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
704 %*********************************************************
708 %*********************************************************
711 newLocalsRn :: [Located RdrName] -> RnM [Name]
712 newLocalsRn rdr_names_w_loc
713 = newUniqueSupply `thenM` \ us ->
714 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
716 mk (L loc rdr_name) uniq
717 | Just name <- isExact_maybe rdr_name = name
718 -- This happens in code generated by Template Haskell
719 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
720 -- We only bind unqualified names here
721 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
722 mkInternalName uniq (rdrNameOcc rdr_name) loc
724 ---------------------
725 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
726 checkDupAndShadowedRdrNames doc loc_rdr_names
727 = do { checkDupRdrNames doc loc_rdr_names
729 ; checkShadowedNames doc envs
730 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
732 ---------------------
733 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
737 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
738 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
740 -- Make fresh Names and extend the environment
741 newLocalsRn rdr_names_w_loc `thenM` \names ->
742 bindLocalNames names (enclosed_scope names)
744 bindLocalNames :: [Name] -> RnM a -> RnM a
745 bindLocalNames names enclosed_scope
746 = getLocalRdrEnv `thenM` \ name_env ->
747 setLocalRdrEnv (extendLocalRdrEnv name_env names)
750 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
751 bindLocalNamesFV names enclosed_scope
752 = do { (result, fvs) <- bindLocalNames names enclosed_scope
753 ; returnM (result, delListFromNameSet fvs names) }
756 -------------------------------------
757 -- binLocalsFVRn is the same as bindLocalsRn
758 -- except that it deals with free vars
759 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
760 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
761 bindLocatedLocalsFV doc rdr_names enclosed_scope
762 = bindLocatedLocalsRn doc rdr_names $ \ names ->
763 enclosed_scope names `thenM` \ (thing, fvs) ->
764 returnM (thing, delListFromNameSet fvs names)
766 -------------------------------------
767 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
768 -> ([LHsTyVarBndr Name] -> RnM a)
770 -- Haskell-98 binding of type variables; e.g. within a data type decl
771 bindTyVarsRn doc_str tyvar_names enclosed_scope
773 located_tyvars = hsLTyVarLocNames tyvar_names
775 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
776 enclosed_scope (zipWith replace tyvar_names names)
778 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
780 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
781 -- Find the type variables in the pattern type
782 -- signatures that must be brought into scope
783 bindPatSigTyVars tys thing_inside
784 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
785 ; if not scoped_tyvars then
788 do { name_env <- getLocalRdrEnv
789 ; let locd_tvs = [ tv | ty <- tys
790 , tv <- extractHsTyRdrTyVars ty
791 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
792 nubbed_tvs = nubBy eqLocated locd_tvs
793 -- The 'nub' is important. For example:
794 -- f (x :: t) (y :: t) = ....
795 -- We don't want to complain about binding t twice!
797 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
799 doc_sig = text "In a pattern type-signature"
801 bindPatSigTyVarsFV :: [LHsType RdrName]
804 bindPatSigTyVarsFV tys thing_inside
805 = bindPatSigTyVars tys $ \ tvs ->
806 thing_inside `thenM` \ (result,fvs) ->
807 returnM (result, fvs `delListFromNameSet` tvs)
809 bindSigTyVarsFV :: [Name]
812 bindSigTyVarsFV tvs thing_inside
813 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
814 ; if not scoped_tyvars then
817 bindLocalNamesFV tvs thing_inside }
819 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
820 -- This function is used only in rnSourceDecl on InstDecl
821 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
823 -------------------------------------
824 checkDupRdrNames :: SDoc
827 checkDupRdrNames doc_str rdr_names_w_loc
828 = -- Check for duplicated names in a binding group
829 mappM_ (dupNamesErr getLoc doc_str) dups
831 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
833 checkDupNames :: SDoc
836 checkDupNames doc_str names
837 = -- Check for duplicated names in a binding group
838 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
840 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
842 -------------------------------------
843 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
844 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
845 = ifOptM Opt_WarnNameShadowing $
846 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
847 ; mappM_ check_shadow loc_rdr_names }
849 check_shadow (loc, occ)
850 | Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
851 | not (null gres) = complain (map pprNameProvenance gres)
852 | otherwise = return ()
854 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
855 mb_local = lookupLocalRdrOcc local_env occ
856 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
857 -- Make an Unqualified RdrName and look that up, so that
858 -- we don't find any GREs that are in scope qualified-only
862 %************************************************************************
864 \subsection{Free variable manipulation}
866 %************************************************************************
870 mapFvRn :: (a -> RnM (b, FreeVars)) -> [a] -> RnM ([b], FreeVars)
871 mapFvRn f xs = do stuff <- mappM f xs
873 (ys, fvs_s) -> returnM (ys, plusFVs fvs_s)
875 -- because some of the rename functions are CPSed:
876 -- maps the function across the list from left to right;
877 -- collects all the free vars into one set
878 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
879 -> [a] -> ([b] -> RnM c) -> RnM c
881 mapFvRnCPS _ [] cont = cont []
882 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
883 mapFvRnCPS f xs $ \ xs' ->
888 %************************************************************************
890 \subsection{Envt utility functions}
892 %************************************************************************
895 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
896 warnUnusedModules mods
897 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
899 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
900 mk_warn m = vcat [ptext (sLit "Module") <+> quotes (ppr m)
901 <+> text "is imported, but nothing from it is used,",
902 nest 2 (ptext (sLit "except perhaps instances visible in")
904 ptext (sLit "To suppress this warning, use:")
905 <+> ptext (sLit "import") <+> ppr m <> parens empty ]
908 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
909 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
910 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
912 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
913 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
914 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
916 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
917 check_unused flag bound_names used_names
918 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
920 -------------------------
922 warnUnusedGREs :: [GlobalRdrElt] -> RnM ()
924 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
926 warnUnusedLocals :: [Name] -> RnM ()
927 warnUnusedLocals names
928 = warnUnusedBinds [(n,LocalDef) | n<-names]
930 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
931 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
932 where reportable (name,_)
933 | isWiredInName name = False -- Don't report unused wired-in names
934 -- Otherwise we get a zillion warnings
936 | otherwise = reportIfUnused (nameOccName name)
938 -------------------------
940 warnUnusedName :: (Name, Provenance) -> RnM ()
941 warnUnusedName (name, LocalDef)
942 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
943 (ptext (sLit "Defined but not used"))
945 warnUnusedName (name, Imported is)
948 warn spec = addUnusedWarning name span msg
950 span = importSpecLoc spec
951 pp_mod = quotes (ppr (importSpecModule spec))
952 msg = ptext (sLit "Imported from") <+> pp_mod <+> ptext (sLit "but not used")
954 addUnusedWarning :: Name -> SrcSpan -> SDoc -> RnM ()
955 addUnusedWarning name span msg
958 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
959 <+> quotes (ppr name)]
963 addNameClashErrRn :: RdrName -> [GlobalRdrElt] -> RnM ()
964 addNameClashErrRn rdr_name names
965 = addErr (vcat [ptext (sLit "Ambiguous occurrence") <+> quotes (ppr rdr_name),
966 ptext (sLit "It could refer to") <+> vcat (msg1 : msgs)])
969 msg1 = ptext (sLit "either") <+> mk_ref np1
970 msgs = [ptext (sLit " or") <+> mk_ref np | np <- nps]
971 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
973 shadowedNameWarn :: SDoc -> OccName -> [SDoc] -> SDoc
974 shadowedNameWarn doc occ shadowed_locs
975 = sep [ptext (sLit "This binding for") <+> quotes (ppr occ)
976 <+> ptext (sLit "shadows the existing binding") <> plural shadowed_locs,
977 nest 2 (vcat shadowed_locs)]
980 unknownNameErr :: RdrName -> SDoc
981 unknownNameErr rdr_name
982 = vcat [ hang (ptext (sLit "Not in scope:"))
983 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
984 <+> quotes (ppr rdr_name))
987 extra | rdr_name == forall_tv_RDR = perhapsForallMsg
990 perhapsForallMsg :: SDoc
992 = vcat [ ptext (sLit "Perhaps you intended to use -XRankNTypes or similar flag")
993 , ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")]
995 unknownSubordinateErr :: SDoc -> RdrName -> SDoc
996 unknownSubordinateErr doc op -- Doc is "method of class" or
997 -- "field of constructor"
998 = quotes (ppr op) <+> ptext (sLit "is not a (visible)") <+> doc
1000 badOrigBinding :: RdrName -> SDoc
1002 = ptext (sLit "Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1003 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1005 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1006 dupNamesErr get_loc descriptor names
1007 = addErrAt big_loc $
1008 vcat [ptext (sLit "Conflicting definitions for") <+> quotes (ppr (head names)),
1009 locations, descriptor]
1011 locs = map get_loc names
1012 big_loc = foldr1 combineSrcSpans locs
1013 one_line = isOneLineSpan big_loc
1014 locations | one_line = empty
1015 | otherwise = ptext (sLit "Bound at:") <+>
1016 vcat (map ppr (sortLe (<=) locs))
1018 badQualBndrErr :: RdrName -> SDoc
1019 badQualBndrErr rdr_name
1020 = ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name