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,
10 lookupLocatedTopBndrRn, lookupTopBndrRn,
11 lookupLocatedOccRn, lookupOccRn,
12 lookupLocatedGlobalOccRn, lookupGlobalOccRn,
13 lookupLocalDataTcNames, lookupSrcOcc_maybe,
14 lookupFixityRn, lookupTyFixityRn, lookupLocatedSigOccRn,
15 lookupLocatedInstDeclBndr,
16 lookupSyntaxName, lookupSyntaxTable, lookupImportedName,
19 newLocalsRn, newIPNameRn,
20 bindLocalNames, bindLocalNamesFV,
21 bindLocatedLocalsFV, bindLocatedLocalsRn,
22 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
23 bindTyVarsRn, extendTyVarEnvFVRn,
26 checkDupNames, mapFvRn,
27 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
28 warnUnusedTopBinds, warnUnusedLocalBinds,
29 dataTcOccs, unknownNameErr,
32 #include "HsVersions.h"
34 import LoadIface ( loadInterfaceForName, loadSrcInterface )
35 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
36 import HsSyn ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
37 LHsTyVarBndr, LHsType,
38 Fixity, hsLTyVarLocNames, replaceTyVarName )
39 import RdrHsSyn ( extractHsTyRdrTyVars )
40 import RdrName ( RdrName, isQual, isUnqual, isOrig_maybe,
42 mkRdrUnqual, setRdrNameSpace, rdrNameOcc,
43 pprGlobalRdrEnv, lookupGRE_RdrName,
44 isExact_maybe, isSrcRdrName,
45 GlobalRdrElt(..), GlobalRdrEnv, lookupGlobalRdrEnv,
46 isLocalGRE, extendLocalRdrEnv, elemLocalRdrEnv, lookupLocalRdrEnv,
47 Provenance(..), pprNameProvenance,
48 importSpecLoc, importSpecModule
50 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity,
51 AvailInfo, GenAvailInfo(..) )
53 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
54 nameSrcLoc, nameOccName, nameModule, isExternalName )
56 import NameEnv ( NameEnv, lookupNameEnv )
57 import OccName ( tcName, isDataOcc, pprNonVarNameSpace, occNameSpace,
59 import Module ( Module, ModuleName )
60 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, consDataConKey, hasKey )
62 import BasicTypes ( IPName, mapIPName )
63 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
64 srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
66 import Util ( sortLe )
67 import ListSetOps ( removeDups )
73 %*********************************************************
77 %*********************************************************
80 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
81 newTopSrcBinder this_mod (L loc rdr_name)
82 | Just name <- isExact_maybe rdr_name
83 = -- This is here to catch
84 -- (a) Exact-name binders created by Template Haskell
85 -- (b) The PrelBase defn of (say) [] and similar, for which
86 -- the parser reads the special syntax and returns an Exact RdrName
87 -- We are at a binding site for the name, so check first that it
88 -- the current module is the correct one; otherwise GHC can get
89 -- very confused indeed. This test rejects code like
90 -- data T = (,) Int Int
91 -- unless we are in GHC.Tup
92 ASSERT2( isExternalName name, ppr name )
93 do { checkM (this_mod == nameModule name)
94 (addErrAt loc (badOrigBinding rdr_name))
98 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
99 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
100 (addErrAt loc (badOrigBinding rdr_name))
101 -- When reading External Core we get Orig names as binders,
102 -- but they should agree with the module gotten from the monad
104 -- We can get built-in syntax showing up here too, sadly. If you type
106 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
107 -- uses setRdrNameSpace to make it into a data constructors. At that point
108 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
109 -- Hence the badOrigBinding error message.
111 -- Except for the ":Main.main = ..." definition inserted into
112 -- the Main module; ugh!
114 -- Because of this latter case, we call newGlobalBinder with a module from
115 -- the RdrName, not from the environment. In principle, it'd be fine to
116 -- have an arbitrary mixture of external core definitions in a single module,
117 -- (apart from module-initialisation issues, perhaps).
118 ; newGlobalBinder rdr_mod rdr_occ (srcSpanStart loc) }
119 --TODO, should pass the whole span
122 = do { checkM (not (isQual rdr_name))
123 (addErrAt loc (badQualBndrErr rdr_name))
124 -- Binders should not be qualified; if they are, and with a different
125 -- module name, we we get a confusing "M.T is not in scope" error later
126 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) (srcSpanStart loc) }
129 %*********************************************************
131 Source code occurrences
133 %*********************************************************
135 Looking up a name in the RnEnv.
138 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
139 lookupLocatedBndrRn = wrapLocM lookupBndrRn
141 lookupBndrRn :: RdrName -> RnM Name
142 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
143 lookupBndrRn rdr_name
144 = getLocalRdrEnv `thenM` \ local_env ->
145 case lookupLocalRdrEnv local_env rdr_name of
146 Just name -> returnM name
147 Nothing -> lookupTopBndrRn rdr_name
149 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
150 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
152 lookupTopBndrRn :: RdrName -> RnM Name
153 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
154 -- and there may be several imported 'f's too, which must not confuse us.
155 -- For example, this is OK:
157 -- infix 9 f -- The 'f' here does not need to be qualified
158 -- f x = x -- Nor here, of course
159 -- So we have to filter out the non-local ones.
161 -- A separate function (importsFromLocalDecls) reports duplicate top level
162 -- decls, so here it's safe just to choose an arbitrary one.
164 -- There should never be a qualified name in a binding position in Haskell,
165 -- but there can be if we have read in an external-Core file.
166 -- The Haskell parser checks for the illegal qualified name in Haskell
167 -- source files, so we don't need to do so here.
169 lookupTopBndrRn rdr_name
170 | Just name <- isExact_maybe rdr_name
173 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
174 -- This deals with the case of derived bindings, where
175 -- we don't bother to call newTopSrcBinder first
176 -- We assume there is no "parent" name
177 = do { loc <- getSrcSpanM
178 ; newGlobalBinder rdr_mod rdr_occ (srcSpanStart loc) }
181 = do { mb_gre <- lookupGreLocalRn rdr_name
183 Nothing -> unboundName rdr_name
184 Just gre -> returnM (gre_name gre) }
186 -- lookupLocatedSigOccRn is used for type signatures and pragmas
192 -- It's clear that the 'f' in the signature must refer to A.f
193 -- The Haskell98 report does not stipulate this, but it will!
194 -- So we must treat the 'f' in the signature in the same way
195 -- as the binding occurrence of 'f', using lookupBndrRn
196 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
197 lookupLocatedSigOccRn = lookupLocatedBndrRn
199 -- lookupInstDeclBndr is used for the binders in an
200 -- instance declaration. Here we use the class name to
203 lookupLocatedInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
204 lookupLocatedInstDeclBndr cls rdr = do
205 imp_avails <- getImports
206 wrapLocM (lookupInstDeclBndr (imp_parent imp_avails) cls) rdr
208 lookupInstDeclBndr :: NameEnv AvailInfo -> Name -> RdrName -> RnM Name
209 -- This is called on the method name on the left-hand side of an
210 -- instance declaration binding. eg. instance Functor T where
212 -- ^^^^ called on this
213 -- Regardless of how many unqualified fmaps are in scope, we want
214 -- the one that comes from the Functor class.
215 lookupInstDeclBndr availenv cls_name rdr_name
216 | isUnqual rdr_name -- Find all the things the rdr-name maps to
217 = do { -- and pick the one with the right parent name
218 let { is_op gre = cls_name == nameParent (gre_name gre)
219 ; occ = rdrNameOcc rdr_name
220 ; lookup_fn env = filter is_op (lookupGlobalRdrEnv env occ) }
221 ; mb_gre <- lookupGreRn_help rdr_name lookup_fn
223 Just gre -> return (gre_name gre)
224 Nothing -> do { addErr (unknownInstBndrErr cls_name rdr_name)
225 ; return (mkUnboundName rdr_name) } }
227 | otherwise -- Occurs in derived instances, where we just
228 -- refer directly to the right method
229 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
230 -- NB: qualified names are rejected by the parser
231 lookupImportedName rdr_name
234 | Just (AvailTC tc subs) <- lookupNameEnv availenv nm = tc
235 | otherwise = nm -- might be an Avail, if the Name is
236 -- in scope some other way
239 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
240 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
242 -- Looking up family names in type instances is a subtle affair. The family
243 -- may be imported, in which case we need to lookup the occurence of a global
244 -- name. Alternatively, the family may be in the same binding group (and in
245 -- fact in a declaration processed later), and we need to create a new top
248 -- So, also this is strictly speaking an occurence, we cannot raise an error
249 -- message yet for instances without a family declaration. This will happen
250 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
252 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
253 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
254 | not (isSrcRdrName rdr_name)
255 = lookupImportedName rdr_name
258 = -- First look up the name in the normal environment.
259 lookupGreRn rdr_name `thenM` \ mb_gre ->
261 Just gre -> returnM (gre_name gre) ;
262 Nothing -> newTopSrcBinder mod lrdr_name }
264 --------------------------------------------------
266 --------------------------------------------------
268 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
269 lookupLocatedOccRn = wrapLocM lookupOccRn
271 -- lookupOccRn looks up an occurrence of a RdrName
272 lookupOccRn :: RdrName -> RnM Name
274 = getLocalRdrEnv `thenM` \ local_env ->
275 case lookupLocalRdrEnv local_env rdr_name of
276 Just name -> returnM name
277 Nothing -> lookupGlobalOccRn rdr_name
279 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
280 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
282 lookupGlobalOccRn :: RdrName -> RnM Name
283 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
284 -- environment. It's used only for
285 -- record field names
286 -- class op names in class and instance decls
288 lookupGlobalOccRn rdr_name
289 | not (isSrcRdrName rdr_name)
290 = lookupImportedName rdr_name
293 = -- First look up the name in the normal environment.
294 lookupGreRn rdr_name `thenM` \ mb_gre ->
296 Just gre -> returnM (gre_name gre) ;
299 -- We allow qualified names on the command line to refer to
300 -- *any* name exported by any module in scope, just as if
301 -- there was an "import qualified M" declaration for every
303 getModule `thenM` \ mod ->
304 if isQual rdr_name && mod == iNTERACTIVE then
305 -- This test is not expensive,
306 lookupQualifiedName rdr_name -- and only happens for failed lookups
308 unboundName rdr_name }
310 lookupImportedName :: RdrName -> TcRnIf m n Name
311 -- Lookup the occurrence of an imported name
312 -- The RdrName is *always* qualified or Exact
313 -- Treat it as an original name, and conjure up the Name
314 -- Usually it's Exact or Orig, but it can be Qual if it
315 -- comes from an hi-boot file. (This minor infelicity is
316 -- just to reduce duplication in the parser.)
317 lookupImportedName rdr_name
318 | Just n <- isExact_maybe rdr_name
319 -- This happens in derived code
322 -- Always Orig, even when reading a .hi-boot file
323 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
324 = lookupOrig rdr_mod rdr_occ
327 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
329 unboundName :: RdrName -> RnM Name
331 = do { addErr (unknownNameErr rdr_name)
332 ; env <- getGlobalRdrEnv;
333 ; traceRn (vcat [unknownNameErr rdr_name,
334 ptext SLIT("Global envt is:"),
335 nest 3 (pprGlobalRdrEnv env)])
336 ; returnM (mkUnboundName rdr_name) }
338 --------------------------------------------------
339 -- Lookup in the Global RdrEnv of the module
340 --------------------------------------------------
342 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
343 -- No filter function; does not report an error on failure
344 lookupSrcOcc_maybe rdr_name
345 = do { mb_gre <- lookupGreRn rdr_name
347 Nothing -> returnM Nothing
348 Just gre -> returnM (Just (gre_name gre)) }
350 -------------------------
351 lookupGreRn :: RdrName -> RnM (Maybe GlobalRdrElt)
352 -- Just look up the RdrName in the GlobalRdrEnv
354 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
356 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
357 -- Similar, but restricted to locally-defined things
358 lookupGreLocalRn rdr_name
359 = lookupGreRn_help rdr_name lookup_fn
361 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
363 lookupGreRn_help :: RdrName -- Only used in error message
364 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
365 -> RnM (Maybe GlobalRdrElt)
366 -- Checks for exactly one match; reports deprecations
367 -- Returns Nothing, without error, if too few
368 lookupGreRn_help rdr_name lookup
369 = do { env <- getGlobalRdrEnv
371 [] -> returnM Nothing
372 [gre] -> returnM (Just gre)
373 gres -> do { addNameClashErrRn rdr_name gres
374 ; returnM (Just (head gres)) } }
376 ------------------------------
378 ------------------------------
380 -- A qualified name on the command line can refer to any module at all: we
381 -- try to load the interface if we don't already have it.
382 lookupQualifiedName :: RdrName -> RnM Name
383 lookupQualifiedName rdr_name
384 | Just (mod,occ) <- isQual_maybe rdr_name
385 -- Note: we want to behave as we would for a source file import here,
386 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
387 = loadSrcInterface doc mod False `thenM` \ iface ->
390 (mod,avails) <- mi_exports iface,
392 name <- availNames avail,
394 ((mod,occ):ns) -> ASSERT (null ns)
396 _ -> unboundName rdr_name
399 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
401 doc = ptext SLIT("Need to find") <+> ppr rdr_name
404 %*********************************************************
408 %*********************************************************
411 lookupLocalDataTcNames :: RdrName -> RnM [Name]
412 -- GHC extension: look up both the tycon and data con
413 -- for con-like things
414 -- Complain if neither is in scope
415 lookupLocalDataTcNames rdr_name
416 | Just n <- isExact_maybe rdr_name
417 -- Special case for (:), which doesn't get into the GlobalRdrEnv
418 = return [n] -- For this we don't need to try the tycon too
420 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
421 ; case [gre_name gre | Just gre <- mb_gres] of
422 [] -> do { addErr (unknownNameErr rdr_name)
424 names -> return names
427 --------------------------------
428 bindLocalFixities :: [FixitySig RdrName] -> RnM a -> RnM a
429 -- Used for nested fixity decls
430 -- No need to worry about type constructors here,
431 -- Should check for duplicates but we don't
432 bindLocalFixities fixes thing_inside
433 | null fixes = thing_inside
434 | otherwise = mappM rn_sig fixes `thenM` \ new_bit ->
435 extendFixityEnv new_bit thing_inside
437 rn_sig (FixitySig lv@(L loc v) fix)
438 = addLocM lookupBndrRn lv `thenM` \ new_v ->
439 returnM (new_v, (FixItem (rdrNameOcc v) fix loc))
442 --------------------------------
443 lookupFixity is a bit strange.
445 * Nested local fixity decls are put in the local fixity env, which we
446 find with getFixtyEnv
448 * Imported fixities are found in the HIT or PIT
450 * Top-level fixity decls in this module may be for Names that are
451 either Global (constructors, class operations)
452 or Local/Exported (everything else)
453 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
454 We put them all in the local fixity environment
457 lookupFixityRn :: Name -> RnM Fixity
459 = getModule `thenM` \ this_mod ->
460 if nameIsLocalOrFrom this_mod name
461 then -- It's defined in this module
462 getFixityEnv `thenM` \ local_fix_env ->
463 traceRn (text "lookupFixityRn" <+> (ppr name $$ ppr local_fix_env)) `thenM_`
464 returnM (lookupFixity local_fix_env name)
466 else -- It's imported
467 -- For imported names, we have to get their fixities by doing a
468 -- loadInterfaceForName, and consulting the Ifaces that comes back
469 -- from that, because the interface file for the Name might not
470 -- have been loaded yet. Why not? Suppose you import module A,
471 -- which exports a function 'f', thus;
472 -- module CurrentModule where
474 -- module A( f ) where
476 -- Then B isn't loaded right away (after all, it's possible that
477 -- nothing from B will be used). When we come across a use of
478 -- 'f', we need to know its fixity, and it's then, and only
479 -- then, that we load B.hi. That is what's happening here.
481 -- loadInterfaceForName will find B.hi even if B is a hidden module,
482 -- and that's what we want.
483 loadInterfaceForName doc name `thenM` \ iface ->
484 returnM (mi_fix_fn iface (nameOccName name))
486 doc = ptext SLIT("Checking fixity for") <+> ppr name
489 lookupTyFixityRn :: Located Name -> RnM Fixity
490 lookupTyFixityRn (L loc n)
491 = do { glaExts <- doptM Opt_GlasgowExts
492 ; when (not glaExts) (addWarnAt loc (infixTyConWarn n))
496 dataTcOccs :: RdrName -> [RdrName]
497 -- If the input is a data constructor, return both it and a type
498 -- constructor. This is useful when we aren't sure which we are
501 | Just n <- isExact_maybe rdr_name -- Ghastly special case
502 , n `hasKey` consDataConKey = [rdr_name] -- see note below
503 | isDataOcc occ = [rdr_name_tc, rdr_name]
504 | otherwise = [rdr_name]
506 occ = rdrNameOcc rdr_name
507 rdr_name_tc = setRdrNameSpace rdr_name tcName
509 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
510 -- and setRdrNameSpace generates an Orig, which is fine
511 -- But it's not fine for (:), because there *is* no corresponding type
512 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
513 -- appear to be in scope (because Orig's simply allocate a new name-cache
514 -- entry) and then we get an error when we use dataTcOccs in
515 -- TcRnDriver.tcRnGetInfo. Large sigh.
518 %************************************************************************
521 Dealing with rebindable syntax is driven by the
522 Opt_NoImplicitPrelude dynamic flag.
524 In "deriving" code we don't want to use rebindable syntax
525 so we switch off the flag locally
528 %************************************************************************
530 Haskell 98 says that when you say "3" you get the "fromInteger" from the
531 Standard Prelude, regardless of what is in scope. However, to experiment
532 with having a language that is less coupled to the standard prelude, we're
533 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
534 happens to be in scope. Then you can
536 import MyPrelude as Prelude
537 to get the desired effect.
539 At the moment this just happens for
540 * fromInteger, fromRational on literals (in expressions and patterns)
541 * negate (in expressions)
542 * minus (arising from n+k patterns)
545 We store the relevant Name in the HsSyn tree, in
546 * HsIntegral/HsFractional
550 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
551 fromRationalName etc), but the renamer changes this to the appropriate user
552 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
554 We treat the orignal (standard) names as free-vars too, because the type checker
555 checks the type of the user thing against the type of the standard thing.
558 lookupSyntaxName :: Name -- The standard name
559 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
560 lookupSyntaxName std_name
561 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
562 if implicit_prelude then normal_case
564 -- Get the similarly named thing from the local environment
565 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
566 returnM (HsVar usr_name, unitFV usr_name)
568 normal_case = returnM (HsVar std_name, emptyFVs)
570 lookupSyntaxTable :: [Name] -- Standard names
571 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
572 lookupSyntaxTable std_names
573 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
574 if implicit_prelude then normal_case
576 -- Get the similarly named thing from the local environment
577 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
579 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
581 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
585 %*********************************************************
589 %*********************************************************
592 newLocalsRn :: [Located RdrName] -> RnM [Name]
593 newLocalsRn rdr_names_w_loc
594 = newUniqueSupply `thenM` \ us ->
595 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
597 mk (L loc rdr_name) uniq
598 | Just name <- isExact_maybe rdr_name = name
599 -- This happens in code generated by Template Haskell
600 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
601 -- We only bind unqualified names here
602 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
603 mkInternalName uniq (rdrNameOcc rdr_name) (srcSpanStart loc)
605 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
609 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
610 = -- Check for duplicate names
611 checkDupNames doc_str rdr_names_w_loc `thenM_`
613 -- Warn about shadowing, but only in source modules
614 ifOptM Opt_WarnNameShadowing
615 (checkShadowing doc_str rdr_names_w_loc) `thenM_`
617 -- Make fresh Names and extend the environment
618 newLocalsRn rdr_names_w_loc `thenM` \ names ->
619 getLocalRdrEnv `thenM` \ local_env ->
620 setLocalRdrEnv (extendLocalRdrEnv local_env names)
621 (enclosed_scope names)
624 bindLocalNames :: [Name] -> RnM a -> RnM a
625 bindLocalNames names enclosed_scope
626 = getLocalRdrEnv `thenM` \ name_env ->
627 setLocalRdrEnv (extendLocalRdrEnv name_env names)
630 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
631 bindLocalNamesFV names enclosed_scope
632 = do { (result, fvs) <- bindLocalNames names enclosed_scope
633 ; returnM (result, delListFromNameSet fvs names) }
636 -------------------------------------
637 -- binLocalsFVRn is the same as bindLocalsRn
638 -- except that it deals with free vars
639 bindLocatedLocalsFV :: SDoc -> [Located RdrName] -> ([Name] -> RnM (a,FreeVars))
641 bindLocatedLocalsFV doc rdr_names enclosed_scope
642 = bindLocatedLocalsRn doc rdr_names $ \ names ->
643 enclosed_scope names `thenM` \ (thing, fvs) ->
644 returnM (thing, delListFromNameSet fvs names)
646 -------------------------------------
647 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
648 -> ([LHsTyVarBndr Name] -> RnM a)
650 -- Haskell-98 binding of type variables; e.g. within a data type decl
651 bindTyVarsRn doc_str tyvar_names enclosed_scope
653 located_tyvars = hsLTyVarLocNames tyvar_names
655 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
656 enclosed_scope (zipWith replace tyvar_names names)
658 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
660 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
661 -- Find the type variables in the pattern type
662 -- signatures that must be brought into scope
663 bindPatSigTyVars tys thing_inside
664 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
665 ; if not scoped_tyvars then
668 do { name_env <- getLocalRdrEnv
669 ; let locd_tvs = [ tv | ty <- tys
670 , tv <- extractHsTyRdrTyVars ty
671 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
672 nubbed_tvs = nubBy eqLocated locd_tvs
673 -- The 'nub' is important. For example:
674 -- f (x :: t) (y :: t) = ....
675 -- We don't want to complain about binding t twice!
677 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
679 doc_sig = text "In a pattern type-signature"
681 bindPatSigTyVarsFV :: [LHsType RdrName]
684 bindPatSigTyVarsFV tys thing_inside
685 = bindPatSigTyVars tys $ \ tvs ->
686 thing_inside `thenM` \ (result,fvs) ->
687 returnM (result, fvs `delListFromNameSet` tvs)
689 bindSigTyVarsFV :: [Name]
692 bindSigTyVarsFV tvs thing_inside
693 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
694 ; if not scoped_tyvars then
697 bindLocalNamesFV tvs thing_inside }
699 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
700 -- This function is used only in rnSourceDecl on InstDecl
701 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
703 -------------------------------------
704 checkDupNames :: SDoc
707 checkDupNames doc_str rdr_names_w_loc
708 = -- Check for duplicated names in a binding group
709 mappM_ (dupNamesErr doc_str) dups
711 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
713 -------------------------------------
714 checkShadowing doc_str loc_rdr_names
715 = getLocalRdrEnv `thenM` \ local_env ->
716 getGlobalRdrEnv `thenM` \ global_env ->
718 check_shadow (L loc rdr_name)
719 | rdr_name `elemLocalRdrEnv` local_env
720 || not (null (lookupGRE_RdrName rdr_name global_env ))
721 = addWarnAt loc (shadowedNameWarn doc_str rdr_name)
722 | otherwise = returnM ()
724 mappM_ check_shadow loc_rdr_names
728 %************************************************************************
730 \subsection{Free variable manipulation}
732 %************************************************************************
736 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
738 (ys, fvs_s) = unzip stuff
740 returnM (ys, plusFVs fvs_s)
744 %************************************************************************
746 \subsection{Envt utility functions}
748 %************************************************************************
751 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
752 warnUnusedModules mods
753 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
755 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
756 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
757 <+> text "is imported, but nothing from it is used,",
758 nest 2 (ptext SLIT("except perhaps instances visible in")
760 ptext SLIT("To suppress this warning, use:")
761 <+> ptext SLIT("import") <+> ppr m <> parens empty ]
764 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
765 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
766 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
768 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM ()
769 warnUnusedLocalBinds names = ifOptM Opt_WarnUnusedBinds (warnUnusedLocals names)
770 warnUnusedMatches names = ifOptM Opt_WarnUnusedMatches (warnUnusedLocals names)
772 -------------------------
775 = warnUnusedBinds [(n,Just p) | GRE {gre_name = n, gre_prov = p} <- gres]
777 warnUnusedLocals names
778 = warnUnusedBinds [(n,Nothing) | n<-names]
780 warnUnusedBinds :: [(Name,Maybe Provenance)] -> RnM ()
781 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
782 where reportable (name,_)
783 | isWiredInName name = False -- Don't report unused wired-in names
784 -- Otherwise we get a zillion warnings
786 | otherwise = reportIfUnused (nameOccName name)
788 -------------------------
790 warnUnusedName :: (Name, Maybe Provenance) -> RnM ()
791 warnUnusedName (name, prov)
794 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
795 <+> quotes (ppr name)]
796 -- TODO should be a proper span
798 (loc,msg) = case prov of
800 -> (importSpecLoc imp_spec, imp_from (importSpecModule imp_spec))
803 other -> (srcLocSpan (nameSrcLoc name), unused_msg)
805 unused_msg = text "Defined but not used"
806 imp_from mod = text "Imported from" <+> quotes (ppr mod) <+> text "but not used"
810 addNameClashErrRn rdr_name names
811 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
812 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
815 msg1 = ptext SLIT("either") <+> mk_ref np1
816 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
817 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
819 shadowedNameWarn doc shadow
820 = hsep [ptext SLIT("This binding for"),
822 ptext SLIT("shadows an existing binding")]
825 unknownNameErr rdr_name
826 = sep [ptext SLIT("Not in scope:"),
827 nest 2 $ pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
828 <+> quotes (ppr rdr_name)]
830 unknownInstBndrErr cls op
831 = quotes (ppr op) <+> ptext SLIT("is not a (visible) method of class") <+> quotes (ppr cls)
834 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
835 -- The rdrNameOcc is because we don't want to print Prelude.(,)
837 dupNamesErr :: SDoc -> [Located RdrName] -> RnM ()
838 dupNamesErr descriptor located_names
840 vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr name1),
841 locations, descriptor]
843 L _ name1 = head located_names
844 locs = map getLoc located_names
845 big_loc = foldr1 combineSrcSpans locs
846 one_line = isOneLineSpan big_loc
847 locations | one_line = empty
848 | otherwise = ptext SLIT("Bound at:") <+>
849 vcat (map ppr (sortLe (<=) locs))
851 badQualBndrErr rdr_name
852 = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name
855 = vcat [ftext FSLIT("Accepting non-standard infix type constructor") <+> quotes (ppr op),
856 ftext FSLIT("Use -fglasgow-exts to avoid this warning")]