2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnEnv]{Environment manipulation for the renamer monad}
7 module RnEnv where -- Export everything
9 #include "HsVersions.h"
11 import {-# SOURCE #-} RnHiFiles( loadInterface )
13 import FlattenInfo ( namesNeededForFlattening )
15 import RnHsSyn ( RenamedFixitySig )
16 import RdrHsSyn ( RdrNameIE, RdrNameHsType, RdrNameFixitySig, extractHsTyRdrTyVars )
17 import RdrName ( RdrName, rdrNameModule, rdrNameOcc, isQual, isUnqual, isOrig,
18 mkRdrUnqual, mkRdrQual, setRdrNameOcc,
19 lookupRdrEnv, foldRdrEnv, rdrEnvToList, elemRdrEnv,
22 import HsTypes ( hsTyVarName, replaceTyVarName )
23 import HscTypes ( Provenance(..), pprNameProvenance, hasBetterProv,
24 ImportReason(..), GlobalRdrEnv, GlobalRdrElt(..), AvailEnv,
25 AvailInfo, Avails, GenAvailInfo(..), NameSupply(..),
26 ModIface(..), GhciMode(..),
27 Deprecations(..), lookupDeprec,
28 extendLocalRdrEnv, lookupFixity
32 getSrcLoc, nameIsLocalOrFrom,
33 mkInternalName, mkExternalName,
34 mkIPName, nameOccName, nameModule_maybe,
35 setNameModuleAndLoc, nameModule
39 import OccName ( OccName, occNameUserString, occNameFlavour,
40 isDataSymOcc, setOccNameSpace, tcName )
41 import Module ( ModuleName, moduleName, mkVanillaModule,
42 mkSysModuleNameFS, moduleNameFS, WhereFrom(..) )
43 import PrelNames ( mkUnboundName,
45 mAIN_Name, main_RDR_Unqual,
46 runIOName, intTyConName,
47 boolTyConName, funTyConName,
48 unpackCStringName, unpackCStringFoldrName, unpackCStringUtf8Name,
49 eqStringName, printName,
50 bindIOName, returnIOName, failIOName, thenIOName
52 import TysWiredIn ( unitTyCon ) -- A little odd
55 import SrcLoc ( SrcLoc, noSrcLoc )
57 import ListSetOps ( removeDups, equivClasses )
58 import Util ( sortLt )
59 import BasicTypes ( mapIPName, defaultFixity )
61 import UniqFM ( lookupWithDefaultUFM )
62 import Maybe ( mapMaybe )
63 import Maybes ( orElse, catMaybes )
65 import FastString ( FastString )
68 %*********************************************************
70 \subsection{Making new names}
72 %*********************************************************
75 newTopBinder :: Module -> RdrName -> SrcLoc -> RnM d Name
76 -- newTopBinder puts into the cache the binder with the
77 -- module information set correctly. When the decl is later renamed,
78 -- the binding site will thereby get the correct module.
79 -- There maybe occurrences that don't have the correct Module, but
80 -- by the typechecker will propagate the binding definition to all
81 -- the occurrences, so that doesn't matter
83 newTopBinder mod rdr_name loc
84 = -- First check the cache
86 -- There should never be a qualified name in a binding position (except in instance decls)
87 -- The parser doesn't check this because the same parser parses instance decls
88 (if isQual rdr_name then
89 qualNameErr (text "In its declaration") (rdr_name,loc)
94 getNameSupplyRn `thenRn` \ name_supply ->
96 occ = rdrNameOcc rdr_name
97 key = (moduleName mod, occ)
98 cache = nsNames name_supply
100 case lookupFM cache key of
102 -- A hit in the cache! We are at the binding site of the name, and
103 -- this is the moment when we know all about
104 -- a) the Name's host Module (in particular, which
105 -- package it comes from)
106 -- b) its defining SrcLoc
107 -- So we update this info
110 new_name = setNameModuleAndLoc name mod loc
111 new_cache = addToFM cache key new_name
113 setNameSupplyRn (name_supply {nsNames = new_cache}) `thenRn_`
114 -- traceRn (text "newTopBinder: overwrite" <+> ppr new_name) `thenRn_`
117 -- Miss in the cache!
118 -- Build a completely new Name, and put it in the cache
119 -- Even for locally-defined names we use implicitImportProvenance;
120 -- updateProvenances will set it to rights
122 (us', us1) = splitUniqSupply (nsUniqs name_supply)
123 uniq = uniqFromSupply us1
124 new_name = mkExternalName uniq mod occ loc
125 new_cache = addToFM cache key new_name
127 setNameSupplyRn (name_supply {nsUniqs = us', nsNames = new_cache}) `thenRn_`
128 -- traceRn (text "newTopBinder: new" <+> ppr new_name) `thenRn_`
132 newGlobalName :: ModuleName -> OccName -> RnM d Name
133 -- Used for *occurrences*. We make a place-holder Name, really just
134 -- to agree on its unique, which gets overwritten when we read in
135 -- the binding occurence later (newTopBinder)
136 -- The place-holder Name doesn't have the right SrcLoc, and its
137 -- Module won't have the right Package either.
139 -- (We have to pass a ModuleName, not a Module, because we may be
140 -- simply looking at an occurrence M.x in an interface file.)
142 -- This means that a renamed program may have incorrect info
143 -- on implicitly-imported occurrences, but the correct info on the
144 -- *binding* declaration. It's the type checker that propagates the
145 -- correct information to all the occurrences.
146 -- Since implicitly-imported names never occur in error messages,
147 -- it doesn't matter that we get the correct info in place till later,
148 -- (but since it affects DLL-ery it does matter that we get it right
150 newGlobalName mod_name occ
151 = getNameSupplyRn `thenRn` \ name_supply ->
153 key = (mod_name, occ)
154 cache = nsNames name_supply
156 case lookupFM cache key of
157 Just name -> -- traceRn (text "newGlobalName: hit" <+> ppr name) `thenRn_`
160 Nothing -> setNameSupplyRn (name_supply {nsUniqs = us', nsNames = new_cache}) `thenRn_`
161 -- traceRn (text "newGlobalName: new" <+> ppr name) `thenRn_`
164 (us', us1) = splitUniqSupply (nsUniqs name_supply)
165 uniq = uniqFromSupply us1
166 mod = mkVanillaModule mod_name
167 name = mkExternalName uniq mod occ noSrcLoc
168 new_cache = addToFM cache key name
170 newIPName rdr_name_ip
171 = getNameSupplyRn `thenRn` \ name_supply ->
173 ipcache = nsIPs name_supply
175 case lookupFM ipcache key of
176 Just name_ip -> returnRn name_ip
177 Nothing -> setNameSupplyRn new_ns `thenRn_`
180 (us', us1) = splitUniqSupply (nsUniqs name_supply)
181 uniq = uniqFromSupply us1
182 name_ip = mapIPName mk_name rdr_name_ip
183 mk_name rdr_name = mkIPName uniq (rdrNameOcc rdr_name)
184 new_ipcache = addToFM ipcache key name_ip
185 new_ns = name_supply {nsUniqs = us', nsIPs = new_ipcache}
187 key = rdr_name_ip -- Ensures that ?x and %x get distinct Names
190 %*********************************************************
192 \subsection{Looking up names}
194 %*********************************************************
196 Looking up a name in the RnEnv.
199 lookupBndrRn rdr_name
200 = getLocalNameEnv `thenRn` \ local_env ->
201 case lookupRdrEnv local_env rdr_name of
202 Just name -> returnRn name
203 Nothing -> lookupTopBndrRn rdr_name
205 lookupTopBndrRn rdr_name
206 -- Look up a top-level local binder. We may be looking up an unqualified 'f',
207 -- and there may be several imported 'f's too, which must not confuse us.
208 -- So we have to filter out the non-local ones.
209 -- A separate function (importsFromLocalDecls) reports duplicate top level
210 -- decls, so here it's safe just to choose an arbitrary one.
213 -- This is here just to catch the PrelBase defn of (say) [] and similar
214 -- The parser reads the special syntax and returns an Orig RdrName
215 -- But the global_env contains only Qual RdrNames, so we won't
216 -- find it there; instead just get the name via the Orig route
218 = -- This is a binding site for the name, so check first that it
219 -- the current module is the correct one; otherwise GHC can get
220 -- very confused indeed. This test rejects code like
221 -- data T = (,) Int Int
222 -- unless we are in GHC.Tup
223 getModuleRn `thenRn` \ mod ->
224 checkRn (moduleName mod == rdrNameModule rdr_name)
225 (badOrigBinding rdr_name) `thenRn_`
226 lookupOrigName rdr_name
229 = getModeRn `thenRn` \ mode ->
230 if isInterfaceMode mode
231 then lookupSysBinder rdr_name
232 -- lookupSysBinder uses the Module in the monad to set
233 -- the correct module for the binder. This is important because
234 -- when GHCi is reading in an old interface, it just sucks it
235 -- in entire (Rename.loadHomeDecls) which uses lookupTopBndrRn
236 -- rather than via the iface file cache which uses newTopBndrRn
237 -- We must get the correct Module into the thing.
240 getModuleRn `thenRn` \ mod ->
241 getGlobalNameEnv `thenRn` \ global_env ->
242 case lookup_local mod global_env rdr_name of
243 Just name -> returnRn name
244 Nothing -> failWithRn (mkUnboundName rdr_name)
245 (unknownNameErr rdr_name)
247 lookup_local mod global_env rdr_name
248 = case lookupRdrEnv global_env rdr_name of
250 Just gres -> case [n | GRE n _ _ <- gres, nameIsLocalOrFrom mod n] of
255 -- lookupSigOccRn is used for type signatures and pragmas
261 -- It's clear that the 'f' in the signature must refer to A.f
262 -- The Haskell98 report does not stipulate this, but it will!
263 -- So we must treat the 'f' in the signature in the same way
264 -- as the binding occurrence of 'f', using lookupBndrRn
265 lookupSigOccRn :: RdrName -> RnMS Name
266 lookupSigOccRn = lookupBndrRn
268 -- lookupInstDeclBndr is used for the binders in an
269 -- instance declaration. Here we use the class name to
272 lookupInstDeclBndr :: Name -> RdrName -> RnMS Name
273 -- We use the selector name as the binder
274 lookupInstDeclBndr cls_name rdr_name
275 | isOrig rdr_name -- Occurs in derived instances, where we just
276 -- refer diectly to the right method
277 = lookupOrigName rdr_name
280 = getGlobalAvails `thenRn` \ avail_env ->
281 case lookupNameEnv avail_env cls_name of
282 -- The class itself isn't in scope, so cls_name is unboundName
283 -- e.g. import Prelude hiding( Ord )
284 -- instance Ord T where ...
285 -- The program is wrong, but that should not cause a crash.
286 Nothing -> returnRn (mkUnboundName rdr_name)
287 Just (AvailTC _ ns) -> case [n | n <- ns, nameOccName n == occ] of
288 (n:ns)-> ASSERT( null ns ) returnRn n
289 [] -> failWithRn (mkUnboundName rdr_name)
290 (unknownNameErr rdr_name)
291 other -> pprPanic "lookupInstDeclBndr" (ppr cls_name)
293 occ = rdrNameOcc rdr_name
295 -- lookupOccRn looks up an occurrence of a RdrName
296 lookupOccRn :: RdrName -> RnMS Name
298 = getLocalNameEnv `thenRn` \ local_env ->
299 case lookupRdrEnv local_env rdr_name of
300 Just name -> returnRn name
301 Nothing -> lookupGlobalOccRn rdr_name
303 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
304 -- environment. It's used only for
305 -- record field names
306 -- class op names in class and instance decls
308 lookupGlobalOccRn rdr_name
309 = getModeRn `thenRn` \ mode ->
310 if (isInterfaceMode mode)
311 then lookupIfaceName rdr_name
314 getGlobalNameEnv `thenRn` \ global_env ->
316 SourceMode -> lookupSrcName global_env rdr_name
319 | not (isQual rdr_name) ->
320 lookupSrcName global_env rdr_name
322 -- We allow qualified names on the command line to refer to
323 -- *any* name exported by any module in scope, just as if
324 -- there was an "import qualified M" declaration for every
327 -- First look up the name in the normal environment. If
328 -- it isn't there, we manufacture a new occurrence of an
331 case lookupRdrEnv global_env rdr_name of
332 Just _ -> lookupSrcName global_env rdr_name
333 Nothing -> lookupQualifiedName rdr_name
335 -- a qualified name on the command line can refer to any module at all: we
336 -- try to load the interface if we don't already have it.
337 lookupQualifiedName :: RdrName -> RnM d Name
338 lookupQualifiedName rdr_name
340 mod = rdrNameModule rdr_name
341 occ = rdrNameOcc rdr_name
343 loadInterface (ppr rdr_name) mod ImportByUser `thenRn` \ iface ->
344 case [ name | (_,avails) <- mi_exports iface,
346 name <- availNames avail,
347 nameOccName name == occ ] of
348 (n:ns) -> ASSERT (null ns) returnRn n
349 _ -> failWithRn (mkUnboundName rdr_name) (unknownNameErr rdr_name)
351 lookupSrcName :: GlobalRdrEnv -> RdrName -> RnM d Name
352 -- NB: passed GlobalEnv explicitly, not necessarily in RnMS monad
353 lookupSrcName global_env rdr_name
354 | isOrig rdr_name -- Can occur in source code too
355 = lookupOrigName rdr_name
358 = case lookupRdrEnv global_env rdr_name of
359 Just [GRE name _ Nothing] -> returnRn name
360 Just [GRE name _ (Just deprec)] -> warnDeprec name deprec `thenRn_`
362 Just stuff@(GRE name _ _ : _) -> addNameClashErrRn rdr_name stuff `thenRn_`
364 Nothing -> failWithRn (mkUnboundName rdr_name)
365 (unknownNameErr rdr_name)
367 lookupOrigName :: RdrName -> RnM d Name
368 lookupOrigName rdr_name
369 = -- NO: ASSERT( isOrig rdr_name )
370 -- Now that .hi-boot files are read by the main parser, they contain
371 -- ordinary qualified names (which we treat as Orig names here).
372 newGlobalName (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
374 lookupIfaceUnqual :: RdrName -> RnM d Name
375 lookupIfaceUnqual rdr_name
376 = ASSERT( isUnqual rdr_name )
377 -- An Unqual is allowed; interface files contain
378 -- unqualified names for locally-defined things, such as
379 -- constructors of a data type.
380 getModuleRn `thenRn ` \ mod ->
381 newGlobalName (moduleName mod) (rdrNameOcc rdr_name)
383 lookupIfaceName :: RdrName -> RnM d Name
384 lookupIfaceName rdr_name
385 | isUnqual rdr_name = lookupIfaceUnqual rdr_name
386 | otherwise = lookupOrigName rdr_name
389 @lookupOrigName@ takes an RdrName representing an {\em original}
390 name, and adds it to the occurrence pool so that it'll be loaded
391 later. This is used when language constructs (such as monad
392 comprehensions, overloaded literals, or deriving clauses) require some
393 stuff to be loaded that isn't explicitly mentioned in the code.
395 This doesn't apply in interface mode, where everything is explicit,
396 but we don't check for this case: it does no harm to record an
397 ``extra'' occurrence and @lookupOrigNames@ isn't used much in
398 interface mode (it's only the @Nothing@ clause of @rnDerivs@ that
399 calls it at all I think).
401 \fbox{{\em Jan 98: this comment is wrong: @rnHsType@ uses it quite a bit.}}
404 lookupOrigNames :: [RdrName] -> RnM d NameSet
405 lookupOrigNames rdr_names
406 = mapRn lookupOrigName rdr_names `thenRn` \ names ->
407 returnRn (mkNameSet names)
410 lookupSysBinder is used for the "system binders" of a type, class, or
411 instance decl. It ensures that the module is set correctly in the
412 name cache, and sets the provenance on the returned name too. The
413 returned name will end up actually in the type, class, or instance.
416 lookupSysBinder rdr_name
417 = ASSERT( isUnqual rdr_name )
418 getModuleRn `thenRn` \ mod ->
419 getSrcLocRn `thenRn` \ loc ->
420 newTopBinder mod rdr_name loc
424 %*********************************************************
426 \subsection{Looking up fixities}
428 %*********************************************************
430 lookupFixity is a bit strange.
432 * Nested local fixity decls are put in the local fixity env, which we
433 find with getFixtyEnv
435 * Imported fixities are found in the HIT or PIT
437 * Top-level fixity decls in this module may be for Names that are
438 either Global (constructors, class operations)
439 or Local/Exported (everything else)
440 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
441 We put them all in the local fixity environment
444 lookupFixityRn :: Name -> RnMS Fixity
446 = getModuleRn `thenRn` \ this_mod ->
447 if nameIsLocalOrFrom this_mod name
448 then -- It's defined in this module
449 getFixityEnv `thenRn` \ local_fix_env ->
450 returnRn (lookupLocalFixity local_fix_env name)
452 else -- It's imported
453 -- For imported names, we have to get their fixities by doing a
454 -- loadHomeInterface, and consulting the Ifaces that comes back
455 -- from that, because the interface file for the Name might not
456 -- have been loaded yet. Why not? Suppose you import module A,
457 -- which exports a function 'f', thus;
458 -- module CurrentModule where
460 -- module A( f ) where
462 -- Then B isn't loaded right away (after all, it's possible that
463 -- nothing from B will be used). When we come across a use of
464 -- 'f', we need to know its fixity, and it's then, and only
465 -- then, that we load B.hi. That is what's happening here.
466 loadInterface doc name_mod ImportBySystem `thenRn` \ iface ->
467 returnRn (lookupFixity (mi_fixities iface) name)
469 doc = ptext SLIT("Checking fixity for") <+> ppr name
470 name_mod = moduleName (nameModule name)
472 --------------------------------
473 lookupLocalFixity :: LocalFixityEnv -> Name -> Fixity
474 lookupLocalFixity env name
475 = case lookupNameEnv env name of
476 Just (FixitySig _ fix _) -> fix
477 Nothing -> defaultFixity
479 extendNestedFixityEnv :: [(Name, RenamedFixitySig)] -> RnMS a -> RnMS a
480 -- Used for nested fixity decls
481 -- No need to worry about type constructors here,
482 -- Should check for duplicates but we don't
483 extendNestedFixityEnv fixes enclosed_scope
484 = getFixityEnv `thenRn` \ fix_env ->
486 new_fix_env = extendNameEnvList fix_env fixes
488 setFixityEnv new_fix_env enclosed_scope
490 mkTopFixityEnv :: GlobalRdrEnv -> [RdrNameFixitySig] -> RnMG LocalFixityEnv
491 mkTopFixityEnv gbl_env fix_sigs
492 = getModuleRn `thenRn` \ mod ->
494 -- GHC extension: look up both the tycon and data con
495 -- for con-like things
496 -- If neither are in scope, report an error; otherwise
497 -- add both to the fixity env
498 go fix_env (FixitySig rdr_name fixity loc)
499 = case catMaybes (map (lookup_local mod gbl_env) rdr_names) of
500 [] -> pushSrcLocRn loc $
501 addErrRn (unknownNameErr rdr_name) `thenRn_`
503 ns -> foldlRn add fix_env ns
507 = case lookupNameEnv fix_env name of
508 Just (FixitySig _ _ loc') -> addErrRn (dupFixityDecl rdr_name loc loc') `thenRn_`
510 Nothing -> returnRn (extendNameEnv fix_env name (FixitySig name fixity loc))
512 rdr_names | isDataSymOcc occ = [rdr_name, rdr_name_tc]
513 | otherwise = [rdr_name]
515 occ = rdrNameOcc rdr_name
516 rdr_name_tc = setRdrNameOcc rdr_name (setOccNameSpace occ tcName)
518 foldlRn go emptyLocalFixityEnv fix_sigs
522 %*********************************************************
524 \subsection{Implicit free vars and sugar names}
526 %*********************************************************
528 @getXImplicitFVs@ forces the renamer to slurp in some things which aren't
529 mentioned explicitly, but which might be needed by the type checker.
532 getImplicitStmtFVs -- Compiling a statement
533 = returnRn (mkFVs [printName, bindIOName, thenIOName,
534 returnIOName, failIOName]
535 `plusFV` ubiquitousNames)
536 -- These are all needed implicitly when compiling a statement
537 -- See TcModule.tc_stmts
539 getImplicitModuleFVs decls -- Compiling a module
540 = lookupOrigNames deriv_occs `thenRn` \ deriving_names ->
541 returnRn (deriving_names `plusFV` ubiquitousNames)
543 -- deriv_classes is now a list of HsTypes, so a "normal" one
544 -- appears as a (HsClassP c []). The non-normal ones for the new
545 -- newtype-deriving extension, and they don't require any
546 -- implicit names, so we can silently filter them out.
547 deriv_occs = [occ | TyClD (TyData {tcdDerivs = Just deriv_classes}) <- decls,
548 HsClassP cls [] <- deriv_classes,
549 occ <- lookupWithDefaultUFM derivingOccurrences [] cls ]
551 -- ubiquitous_names are loaded regardless, because
552 -- they are needed in virtually every program
554 = mkFVs [unpackCStringName, unpackCStringFoldrName,
555 unpackCStringUtf8Name, eqStringName]
556 -- Virtually every program has error messages in it somewhere
559 mkFVs [getName unitTyCon, funTyConName, boolTyConName, intTyConName]
560 -- Add occurrences for very frequently used types.
561 -- (e.g. we don't want to be bothered with making funTyCon a
562 -- free var at every function application!)
564 namesNeededForFlattening
565 -- this will be empty unless flattening is activated
567 checkMain ghci_mode mod_name gbl_env
568 -- LOOKUP main IF WE'RE IN MODULE Main
569 -- The main point of this is to drag in the declaration for 'main',
570 -- its in another module, and for the Prelude function 'runIO',
571 -- so that the type checker will find them
573 -- We have to return the main_name separately, because it's a
574 -- bona fide 'use', and should be recorded as such, but the others
576 | mod_name /= mAIN_Name
577 = returnRn (Nothing, emptyFVs, emptyFVs)
579 | not (main_RDR_Unqual `elemRdrEnv` gbl_env)
580 = complain_no_main `thenRn_`
581 returnRn (Nothing, emptyFVs, emptyFVs)
584 = lookupSrcName gbl_env main_RDR_Unqual `thenRn` \ main_name ->
585 returnRn (Just main_name, unitFV main_name, unitFV runIOName)
588 complain_no_main | ghci_mode == Interactive = addWarnRn noMainMsg
589 | otherwise = addErrRn noMainMsg
590 -- In interactive mode, only warn about the absence of main
593 %************************************************************************
595 \subsection{Re-bindable desugaring names}
597 %************************************************************************
599 Haskell 98 says that when you say "3" you get the "fromInteger" from the
600 Standard Prelude, regardless of what is in scope. However, to experiment
601 with having a language that is less coupled to the standard prelude, we're
602 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
603 happens to be in scope. Then you can
605 import MyPrelude as Prelude
606 to get the desired effect.
608 At the moment this just happens for
609 * fromInteger, fromRational on literals (in expressions and patterns)
610 * negate (in expressions)
611 * minus (arising from n+k patterns)
614 We store the relevant Name in the HsSyn tree, in
615 * HsIntegral/HsFractional
619 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
620 fromRationalName etc), but the renamer changes this to the appropriate user
621 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
623 We treat the orignal (standard) names as free-vars too, because the type checker
624 checks the type of the user thing against the type of the standard thing.
627 lookupSyntaxName :: Name -- The standard name
628 -> RnMS (Name, FreeVars) -- Possibly a non-standard name
629 lookupSyntaxName std_name
630 = getModeRn `thenRn` \ mode ->
632 InterfaceMode -> returnRn (std_name, unitFV std_name) ;
633 -- Happens for 'derived' code
634 -- where we don't want to rebind
637 doptRn Opt_NoImplicitPrelude `thenRn` \ no_prelude ->
638 if not no_prelude then
639 returnRn (std_name, unitFV std_name) -- Normal case
641 -- Get the similarly named thing from the local environment
642 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenRn` \ usr_name ->
643 returnRn (usr_name, mkFVs [usr_name, std_name]) }
647 %*********************************************************
651 %*********************************************************
654 newLocalsRn :: [(RdrName,SrcLoc)]
656 newLocalsRn rdr_names_w_loc
657 = getNameSupplyRn `thenRn` \ name_supply ->
659 (us', us1) = splitUniqSupply (nsUniqs name_supply)
660 uniqs = uniqsFromSupply us1
661 names = [ mkInternalName uniq (rdrNameOcc rdr_name) loc
662 | ((rdr_name,loc), uniq) <- rdr_names_w_loc `zip` uniqs
665 setNameSupplyRn (name_supply {nsUniqs = us'}) `thenRn_`
669 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
670 -> [(RdrName,SrcLoc)]
671 -> ([Name] -> RnMS a)
673 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
674 = getModeRn `thenRn` \ mode ->
675 getLocalNameEnv `thenRn` \ local_env ->
676 getGlobalNameEnv `thenRn` \ global_env ->
678 -- Check for duplicate names
679 checkDupOrQualNames doc_str rdr_names_w_loc `thenRn_`
681 -- Warn about shadowing, but only in source modules
683 check_shadow (rdr_name,loc)
684 | rdr_name `elemRdrEnv` local_env
685 || rdr_name `elemRdrEnv` global_env
686 = pushSrcLocRn loc $ addWarnRn (shadowedNameWarn rdr_name)
692 SourceMode -> ifOptRn Opt_WarnNameShadowing $
693 mapRn_ check_shadow rdr_names_w_loc
697 newLocalsRn rdr_names_w_loc `thenRn` \ names ->
699 new_local_env = addListToRdrEnv local_env (map fst rdr_names_w_loc `zip` names)
701 setLocalNameEnv new_local_env (enclosed_scope names)
703 bindCoreLocalRn :: RdrName -> (Name -> RnMS a) -> RnMS a
704 -- A specialised variant when renaming stuff from interface
705 -- files (of which there is a lot)
707 -- * no checks for shadowing
709 -- * deal with free vars
710 bindCoreLocalRn rdr_name enclosed_scope
711 = getSrcLocRn `thenRn` \ loc ->
712 getLocalNameEnv `thenRn` \ name_env ->
713 getNameSupplyRn `thenRn` \ name_supply ->
715 (us', us1) = splitUniqSupply (nsUniqs name_supply)
716 uniq = uniqFromSupply us1
717 name = mkInternalName uniq (rdrNameOcc rdr_name) loc
719 setNameSupplyRn (name_supply {nsUniqs = us'}) `thenRn_`
721 new_name_env = extendRdrEnv name_env rdr_name name
723 setLocalNameEnv new_name_env (enclosed_scope name)
725 bindCoreLocalsRn [] thing_inside = thing_inside []
726 bindCoreLocalsRn (b:bs) thing_inside = bindCoreLocalRn b $ \ name' ->
727 bindCoreLocalsRn bs $ \ names' ->
728 thing_inside (name':names')
730 bindLocalNames names enclosed_scope
731 = getLocalNameEnv `thenRn` \ name_env ->
732 setLocalNameEnv (extendLocalRdrEnv name_env names)
735 bindLocalNamesFV names enclosed_scope
736 = bindLocalNames names $
737 enclosed_scope `thenRn` \ (thing, fvs) ->
738 returnRn (thing, delListFromNameSet fvs names)
741 -------------------------------------
742 bindLocalRn doc rdr_name enclosed_scope
743 = getSrcLocRn `thenRn` \ loc ->
744 bindLocatedLocalsRn doc [(rdr_name,loc)] $ \ (n:ns) ->
748 bindLocalsRn doc rdr_names enclosed_scope
749 = getSrcLocRn `thenRn` \ loc ->
750 bindLocatedLocalsRn doc
751 (rdr_names `zip` repeat loc)
754 -- binLocalsFVRn is the same as bindLocalsRn
755 -- except that it deals with free vars
756 bindLocalsFVRn doc rdr_names enclosed_scope
757 = bindLocalsRn doc rdr_names $ \ names ->
758 enclosed_scope names `thenRn` \ (thing, fvs) ->
759 returnRn (thing, delListFromNameSet fvs names)
761 -------------------------------------
762 extendTyVarEnvFVRn :: [Name] -> RnMS (a, FreeVars) -> RnMS (a, FreeVars)
763 -- This tiresome function is used only in rnSourceDecl on InstDecl
764 extendTyVarEnvFVRn tyvars enclosed_scope
765 = bindLocalNames tyvars enclosed_scope `thenRn` \ (thing, fvs) ->
766 returnRn (thing, delListFromNameSet fvs tyvars)
768 bindTyVarsRn :: SDoc -> [HsTyVarBndr RdrName]
769 -> ([HsTyVarBndr Name] -> RnMS a)
771 bindTyVarsRn doc_str tyvar_names enclosed_scope
772 = getSrcLocRn `thenRn` \ loc ->
774 located_tyvars = [(hsTyVarName tv, loc) | tv <- tyvar_names]
776 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
777 enclosed_scope (zipWith replaceTyVarName tyvar_names names)
779 bindPatSigTyVars :: [RdrNameHsType]
780 -> RnMS (a, FreeVars)
781 -> RnMS (a, FreeVars)
782 -- Find the type variables in the pattern type
783 -- signatures that must be brought into scope
785 bindPatSigTyVars tys enclosed_scope
786 = getLocalNameEnv `thenRn` \ name_env ->
787 getSrcLocRn `thenRn` \ loc ->
789 forall_tyvars = nub [ tv | ty <- tys,
790 tv <- extractHsTyRdrTyVars ty,
791 not (tv `elemFM` name_env)
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 located_tyvars = [(tv, loc) | tv <- forall_tyvars]
798 doc_sig = text "In a pattern type-signature"
800 bindLocatedLocalsRn doc_sig located_tyvars $ \ names ->
801 enclosed_scope `thenRn` \ (thing, fvs) ->
802 returnRn (thing, delListFromNameSet fvs names)
805 -------------------------------------
806 checkDupOrQualNames, checkDupNames :: SDoc
807 -> [(RdrName, SrcLoc)]
809 -- Works in any variant of the renamer monad
811 checkDupOrQualNames doc_str rdr_names_w_loc
812 = -- Check for use of qualified names
813 mapRn_ (qualNameErr doc_str) quals `thenRn_`
814 checkDupNames doc_str rdr_names_w_loc
816 quals = filter (isQual . fst) rdr_names_w_loc
818 checkDupNames doc_str rdr_names_w_loc
819 = -- Check for duplicated names in a binding group
820 mapRn_ (dupNamesErr doc_str) dups
822 (_, dups) = removeDups (\(n1,l1) (n2,l2) -> n1 `compare` n2) rdr_names_w_loc
826 %************************************************************************
828 \subsection{GlobalRdrEnv}
830 %************************************************************************
833 mkGlobalRdrEnv :: ModuleName -- Imported module (after doing the "as M" name change)
834 -> Bool -- True <=> want unqualified import
835 -> (Name -> Provenance)
836 -> Avails -- Whats imported
840 mkGlobalRdrEnv this_mod unqual_imp mk_provenance avails deprecs
843 -- Make the name environment. We're talking about a
844 -- single module here, so there must be no name clashes.
845 -- In practice there only ever will be if it's the module
848 -- Add qualified names for the things that are available
849 -- (Qualified names are always imported)
850 gbl_env1 = foldl add_avail emptyRdrEnv avails
852 -- Add unqualified names
853 gbl_env2 | unqual_imp = foldl add_unqual gbl_env1 (rdrEnvToList gbl_env1)
854 | otherwise = gbl_env1
856 add_unqual env (qual_name, elts)
857 = foldl add_one env elts
859 add_one env elt = addOneToGlobalRdrEnv env unqual_name elt
860 unqual_name = unqualifyRdrName qual_name
861 -- The qualified import should only have added one
862 -- binding for each qualified name! But if there's an error in
863 -- the module (multiple bindings for the same name) we may get
864 -- duplicates. So the simple thing is to do the fold.
866 add_avail :: GlobalRdrEnv -> AvailInfo -> GlobalRdrEnv
867 add_avail env avail = foldl add_name env (availNames avail)
869 add_name env name -- Add qualified name only
870 = addOneToGlobalRdrEnv env (mkRdrQual this_mod occ) elt
872 occ = nameOccName name
873 elt = GRE name (mk_provenance name) (lookupDeprec deprecs name)
877 plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
878 plusGlobalRdrEnv env1 env2 = plusFM_C combine_globals env1 env2
880 addOneToGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> GlobalRdrElt -> GlobalRdrEnv
881 addOneToGlobalRdrEnv env rdr_name name = addToFM_C combine_globals env rdr_name [name]
883 delOneFromGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> GlobalRdrEnv
884 delOneFromGlobalRdrEnv env rdr_name = delFromFM env rdr_name
886 combine_globals :: [GlobalRdrElt] -- Old
887 -> [GlobalRdrElt] -- New
889 combine_globals ns_old ns_new -- ns_new is often short
890 = foldr add ns_old ns_new
892 add n ns | any (is_duplicate n) ns_old = map (choose n) ns -- Eliminate duplicates
895 choose n m | n `beats` m = n
898 (GRE n pn _) `beats` (GRE m pm _) = n==m && pn `hasBetterProv` pm
900 is_duplicate :: GlobalRdrElt -> GlobalRdrElt -> Bool
901 is_duplicate (GRE n1 LocalDef _) (GRE n2 LocalDef _) = False
902 is_duplicate (GRE n1 _ _) (GRE n2 _ _) = n1 == n2
905 We treat two bindings of a locally-defined name as a duplicate,
906 because they might be two separate, local defns and we want to report
907 and error for that, {\em not} eliminate a duplicate.
909 On the other hand, if you import the same name from two different
910 import statements, we {\em do} want to eliminate the duplicate, not report
913 If a module imports itself then there might be a local defn and an imported
914 defn of the same name; in this case the names will compare as equal, but
915 will still have different provenances.
918 @unQualInScope@ returns a function that takes a @Name@ and tells whether
919 its unqualified name is in scope. This is put as a boolean flag in
920 the @Name@'s provenance to guide whether or not to print the name qualified
924 unQualInScope :: GlobalRdrEnv -> Name -> Bool
925 -- True if 'f' is in scope, and has only one binding,
926 -- and the thing it is bound to is the name we are looking for
927 -- (i.e. false if A.f and B.f are both in scope as unqualified 'f')
929 -- This fn is only efficient if the shared
930 -- partial application is used a lot.
932 = (`elemNameSet` unqual_names)
934 unqual_names :: NameSet
935 unqual_names = foldRdrEnv add emptyNameSet env
936 add rdr_name [GRE name _ _] unquals | isUnqual rdr_name = addOneToNameSet unquals name
937 add _ _ unquals = unquals
941 %************************************************************************
945 %************************************************************************
948 plusAvail (Avail n1) (Avail n2) = Avail n1
949 plusAvail (AvailTC n1 ns1) (AvailTC n2 ns2) = AvailTC n2 (nub (ns1 ++ ns2))
952 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
955 addAvail :: AvailEnv -> AvailInfo -> AvailEnv
956 addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail
958 unitAvailEnv :: AvailInfo -> AvailEnv
959 unitAvailEnv a = unitNameEnv (availName a) a
961 plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
962 plusAvailEnv = plusNameEnv_C plusAvail
964 availEnvElts = nameEnvElts
966 addAvailToNameSet :: NameSet -> AvailInfo -> NameSet
967 addAvailToNameSet names avail = addListToNameSet names (availNames avail)
969 availsToNameSet :: [AvailInfo] -> NameSet
970 availsToNameSet avails = foldl addAvailToNameSet emptyNameSet avails
972 availName :: GenAvailInfo name -> name
973 availName (Avail n) = n
974 availName (AvailTC n _) = n
976 availNames :: GenAvailInfo name -> [name]
977 availNames (Avail n) = [n]
978 availNames (AvailTC n ns) = ns
980 -------------------------------------
981 filterAvail :: RdrNameIE -- Wanted
982 -> AvailInfo -- Available
983 -> Maybe AvailInfo -- Resulting available;
984 -- Nothing if (any of the) wanted stuff isn't there
986 filterAvail ie@(IEThingWith want wants) avail@(AvailTC n ns)
987 | sub_names_ok = Just (AvailTC n (filter is_wanted ns))
988 | otherwise = Nothing
990 is_wanted name = nameOccName name `elem` wanted_occs
991 sub_names_ok = all (`elem` avail_occs) wanted_occs
992 avail_occs = map nameOccName ns
993 wanted_occs = map rdrNameOcc (want:wants)
995 filterAvail (IEThingAbs _) (AvailTC n ns) = ASSERT( n `elem` ns )
998 filterAvail (IEThingAbs _) avail@(Avail n) = Just avail -- Type synonyms
1000 filterAvail (IEVar _) avail@(Avail n) = Just avail
1001 filterAvail (IEVar v) avail@(AvailTC n ns) = Just (AvailTC n (filter wanted ns))
1003 wanted n = nameOccName n == occ
1005 -- The second equation happens if we import a class op, thus
1007 -- where op is a class operation
1009 filterAvail (IEThingAll _) avail@(AvailTC _ _) = Just avail
1010 -- We don't complain even if the IE says T(..), but
1011 -- no constrs/class ops of T are available
1012 -- Instead that's caught with a warning by the caller
1014 filterAvail ie avail = Nothing
1016 -------------------------------------
1017 groupAvails :: Module -> Avails -> [(ModuleName, Avails)]
1018 -- Group by module and sort by occurrence
1019 -- This keeps the list in canonical order
1020 groupAvails this_mod avails
1021 = [ (mkSysModuleNameFS fs, sortLt lt avails)
1022 | (fs,avails) <- fmToList groupFM
1025 groupFM :: FiniteMap FastString Avails
1026 -- Deliberately use the FastString so we
1027 -- get a canonical ordering
1028 groupFM = foldl add emptyFM avails
1030 add env avail = addToFM_C combine env mod_fs [avail']
1032 mod_fs = moduleNameFS (moduleName avail_mod)
1033 avail_mod = case nameModule_maybe (availName avail) of
1036 combine old _ = avail':old
1037 avail' = sortAvail avail
1039 a1 `lt` a2 = occ1 < occ2
1041 occ1 = nameOccName (availName a1)
1042 occ2 = nameOccName (availName a2)
1044 sortAvail :: AvailInfo -> AvailInfo
1045 -- Sort the sub-names into canonical order.
1046 -- The canonical order has the "main name" at the beginning
1047 -- (if it's there at all)
1048 sortAvail (Avail n) = Avail n
1049 sortAvail (AvailTC n ns) | n `elem` ns = AvailTC n (n : sortLt lt (filter (/= n) ns))
1050 | otherwise = AvailTC n ( sortLt lt ns)
1052 n1 `lt` n2 = nameOccName n1 < nameOccName n2
1056 pruneAvails :: (Name -> Bool) -- Keep if this is True
1059 pruneAvails keep avails
1060 = mapMaybe del avails
1062 del :: AvailInfo -> Maybe AvailInfo -- Nothing => nothing left!
1063 del (Avail n) | keep n = Just (Avail n)
1064 | otherwise = Nothing
1065 del (AvailTC n ns) | null ns' = Nothing
1066 | otherwise = Just (AvailTC n ns')
1068 ns' = filter keep ns
1071 %************************************************************************
1073 \subsection{Free variable manipulation}
1075 %************************************************************************
1079 mapFvRn f xs = mapRn f xs `thenRn` \ stuff ->
1081 (ys, fvs_s) = unzip stuff
1083 returnRn (ys, plusFVs fvs_s)
1087 %************************************************************************
1089 \subsection{Envt utility functions}
1091 %************************************************************************
1094 warnUnusedModules :: [ModuleName] -> RnM d ()
1095 warnUnusedModules mods
1096 = ifOptRn Opt_WarnUnusedImports (mapRn_ (addWarnRn . unused_mod) mods)
1098 unused_mod m = vcat [ptext SLIT("Module") <+> quotes (ppr m) <+>
1099 text "is imported, but nothing from it is used",
1100 parens (ptext SLIT("except perhaps to re-export instances visible in") <+>
1103 warnUnusedImports :: [(Name,Provenance)] -> RnM d ()
1104 warnUnusedImports names
1105 = ifOptRn Opt_WarnUnusedImports (warnUnusedBinds names)
1107 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM d ()
1108 warnUnusedLocalBinds names
1109 = ifOptRn Opt_WarnUnusedBinds (warnUnusedBinds [(n,LocalDef) | n<-names])
1111 warnUnusedMatches names
1112 = ifOptRn Opt_WarnUnusedMatches (warnUnusedGroup [(n,LocalDef) | n<-names])
1114 -------------------------
1116 warnUnusedBinds :: [(Name,Provenance)] -> RnM d ()
1117 warnUnusedBinds names
1118 = mapRn_ warnUnusedGroup groups
1120 -- Group by provenance
1121 groups = equivClasses cmp names
1122 (_,prov1) `cmp` (_,prov2) = prov1 `compare` prov2
1125 -------------------------
1127 warnUnusedGroup :: [(Name,Provenance)] -> RnM d ()
1128 warnUnusedGroup names
1129 | null filtered_names = returnRn ()
1130 | not is_local = returnRn ()
1132 = pushSrcLocRn def_loc $
1134 sep [msg <> colon, nest 4 (fsep (punctuate comma (map (ppr.fst) filtered_names)))]
1136 filtered_names = filter reportable names
1137 (name1, prov1) = head filtered_names
1138 (is_local, def_loc, msg)
1140 LocalDef -> (True, getSrcLoc name1, text "Defined but not used")
1142 NonLocalDef (UserImport mod loc _)
1143 -> (True, loc, text "Imported from" <+> quotes (ppr mod) <+> text "but not used")
1145 reportable (name,_) = case occNameUserString (nameOccName name) of
1148 -- Haskell 98 encourages compilers to suppress warnings about
1149 -- unused names in a pattern if they start with "_".
1153 addNameClashErrRn rdr_name (np1:nps)
1154 = addErrRn (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
1155 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
1157 msg1 = ptext SLIT("either") <+> mk_ref np1
1158 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
1159 mk_ref (GRE name prov _) = quotes (ppr name) <> comma <+> pprNameProvenance name prov
1161 shadowedNameWarn shadow
1162 = hsep [ptext SLIT("This binding for"),
1163 quotes (ppr shadow),
1164 ptext SLIT("shadows an existing binding")]
1166 noMainMsg = ptext SLIT("No 'main' defined in module Main")
1169 = sep [text flavour, ptext SLIT("not in scope:"), quotes (ppr name)]
1171 flavour = occNameFlavour (rdrNameOcc name)
1174 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1175 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1177 qualNameErr descriptor (name,loc)
1178 = pushSrcLocRn loc $
1179 addErrRn (vcat [ ptext SLIT("Invalid use of qualified name") <+> quotes (ppr name),
1182 dupNamesErr descriptor ((name,loc) : dup_things)
1183 = pushSrcLocRn loc $
1184 addErrRn ((ptext SLIT("Conflicting definitions for") <+> quotes (ppr name))
1188 warnDeprec :: Name -> DeprecTxt -> RnM d ()
1190 = ifOptRn Opt_WarnDeprecations $
1191 addWarnRn (sep [ text (occNameFlavour (nameOccName name)) <+>
1192 quotes (ppr name) <+> text "is deprecated:",
1195 dupFixityDecl rdr_name loc1 loc2
1196 = vcat [ptext SLIT("Multiple fixity declarations for") <+> quotes (ppr rdr_name),
1197 ptext SLIT("at ") <+> ppr loc1,
1198 ptext SLIT("and") <+> ppr loc2]