2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[RnEnv]{Environment manipulation for the renamer monad}
9 lookupLocatedBndrRn, lookupBndrRn,
10 lookupLocatedTopBndrRn, lookupTopBndrRn,
11 lookupLocatedOccRn, lookupOccRn,
12 lookupLocatedGlobalOccRn, lookupGlobalOccRn,
13 lookupTopFixSigNames, lookupSrcOcc_maybe,
14 lookupFixityRn, lookupLocatedSigOccRn,
15 lookupLocatedInstDeclBndr,
16 lookupSyntaxName, lookupSyntaxNames, lookupImportedName,
18 newLocalsRn, newIPNameRn,
19 bindLocalNames, bindLocalNamesFV,
20 bindLocatedLocalsFV, bindLocatedLocalsRn,
21 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
22 bindTyVarsRn, extendTyVarEnvFVRn,
25 checkDupNames, mapFvRn,
26 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
27 warnUnusedTopBinds, warnUnusedLocalBinds,
28 dataTcOccs, unknownNameErr,
31 #include "HsVersions.h"
33 import LoadIface ( loadHomeInterface, loadSrcInterface )
34 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
35 import HsSyn ( FixitySig(..), ReboundNames, HsExpr(..),
36 HsType(..), HsExplicitForAll(..), LHsTyVarBndr, LHsType,
37 LSig, Sig(..), Fixity, hsLTyVarName, hsLTyVarLocNames, replaceTyVarName )
38 import RdrHsSyn ( extractHsTyRdrTyVars )
39 import RdrName ( RdrName, rdrNameModule, isQual, isUnqual, isOrig,
40 mkRdrUnqual, setRdrNameSpace, rdrNameOcc,
41 pprGlobalRdrEnv, lookupGRE_RdrName,
42 isExact_maybe, isSrcRdrName,
43 GlobalRdrElt(..), GlobalRdrEnv, lookupGlobalRdrEnv,
44 isLocalGRE, extendLocalRdrEnv, elemLocalRdrEnv, lookupLocalRdrEnv,
45 Provenance(..), pprNameProvenance, ImportSpec(..)
47 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity )
49 import Name ( Name, nameIsLocalOrFrom, mkInternalName,
50 nameSrcLoc, nameOccName, nameModule, nameParent, isExternalName )
52 import OccName ( tcName, isDataOcc, occNameFlavour, reportIfUnused )
53 import Module ( Module )
54 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, consDataConKey, hasKey )
56 import BasicTypes ( IPName, mapIPName )
57 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
58 srcLocSpan, getLoc, combineSrcSpans, srcSpanStartLine, srcSpanEndLine )
60 import Util ( sortLe )
61 import ListSetOps ( removeDups )
66 %*********************************************************
70 %*********************************************************
73 newTopSrcBinder :: Module -> Maybe Name -> Located RdrName -> RnM Name
74 newTopSrcBinder this_mod mb_parent (L loc rdr_name)
75 | Just name <- isExact_maybe rdr_name
76 = -- This is here to catch
77 -- (a) Exact-name binders created by Template Haskell
78 -- (b) The PrelBase defn of (say) [] and similar, for which
79 -- the parser reads the special syntax and returns an Exact RdrName
80 -- We are at a binding site for the name, so check first that it
81 -- the current module is the correct one; otherwise GHC can get
82 -- very confused indeed. This test rejects code like
83 -- data T = (,) Int Int
84 -- unless we are in GHC.Tup
85 ASSERT2( isExternalName name, ppr name )
86 do checkErr (this_mod == nameModule name)
87 (badOrigBinding rdr_name)
92 = do checkErr (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
93 (badOrigBinding rdr_name)
94 -- When reading External Core we get Orig names as binders,
95 -- but they should agree with the module gotten from the monad
97 -- We can get built-in syntax showing up here too, sadly. If you type
99 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
100 -- uses setRdrNameSpace to make it into a data constructors. At that point
101 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
102 -- Hence the badOrigBinding error message.
104 -- Except for the ":Main.main = ..." definition inserted into
105 -- the Main module; ugh!
107 -- Because of this latter case, we call newGlobalBinder with a module from
108 -- the RdrName, not from the environment. In principle, it'd be fine to
109 -- have an arbitrary mixture of external core definitions in a single module,
110 -- (apart from module-initialisation issues, perhaps).
111 newGlobalBinder rdr_mod (rdrNameOcc rdr_name) mb_parent
112 (srcSpanStart loc) --TODO, should pass the whole span
115 = newGlobalBinder this_mod (rdrNameOcc rdr_name) mb_parent (srcSpanStart loc)
117 rdr_mod = rdrNameModule rdr_name
120 %*********************************************************
122 Source code occurrences
124 %*********************************************************
126 Looking up a name in the RnEnv.
129 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
130 lookupLocatedBndrRn = wrapLocM lookupBndrRn
132 lookupBndrRn :: RdrName -> RnM Name
133 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
134 lookupBndrRn rdr_name
135 = getLocalRdrEnv `thenM` \ local_env ->
136 case lookupLocalRdrEnv local_env rdr_name of
137 Just name -> returnM name
138 Nothing -> lookupTopBndrRn rdr_name
140 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
141 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
143 lookupTopBndrRn :: RdrName -> RnM Name
144 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
145 -- and there may be several imported 'f's too, which must not confuse us.
146 -- For example, this is OK:
148 -- infix 9 f -- The 'f' here does not need to be qualified
149 -- f x = x -- Nor here, of course
150 -- So we have to filter out the non-local ones.
152 -- A separate function (importsFromLocalDecls) reports duplicate top level
153 -- decls, so here it's safe just to choose an arbitrary one.
155 -- There should never be a qualified name in a binding position in Haskell,
156 -- but there can be if we have read in an external-Core file.
157 -- The Haskell parser checks for the illegal qualified name in Haskell
158 -- source files, so we don't need to do so here.
160 lookupTopBndrRn rdr_name
161 | Just name <- isExact_maybe rdr_name
165 -- This deals with the case of derived bindings, where
166 -- we don't bother to call newTopSrcBinder first
167 -- We assume there is no "parent" name
168 = do { loc <- getSrcSpanM
169 ; newGlobalBinder (rdrNameModule rdr_name)
170 (rdrNameOcc rdr_name) Nothing (srcSpanStart loc) }
173 = do { mb_gre <- lookupGreLocalRn rdr_name
175 Nothing -> unboundName rdr_name
176 Just gre -> returnM (gre_name gre) }
178 -- lookupLocatedSigOccRn is used for type signatures and pragmas
184 -- It's clear that the 'f' in the signature must refer to A.f
185 -- The Haskell98 report does not stipulate this, but it will!
186 -- So we must treat the 'f' in the signature in the same way
187 -- as the binding occurrence of 'f', using lookupBndrRn
188 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
189 lookupLocatedSigOccRn = lookupLocatedBndrRn
191 -- lookupInstDeclBndr is used for the binders in an
192 -- instance declaration. Here we use the class name to
195 lookupLocatedInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
196 lookupLocatedInstDeclBndr cls = wrapLocM (lookupInstDeclBndr cls)
198 lookupInstDeclBndr :: Name -> RdrName -> RnM Name
199 lookupInstDeclBndr cls_name rdr_name
200 | isUnqual rdr_name -- Find all the things the rdr-name maps to
201 = do { -- and pick the one with the right parent name
202 let { is_op gre = cls_name == nameParent (gre_name gre)
203 ; occ = rdrNameOcc rdr_name
204 ; lookup_fn env = filter is_op (lookupGlobalRdrEnv env occ) }
205 ; mb_gre <- lookupGreRn_help rdr_name lookup_fn
207 Just gre -> return (gre_name gre)
208 Nothing -> do { addErr (unknownInstBndrErr cls_name rdr_name)
209 ; return (mkUnboundName rdr_name) } }
211 | otherwise -- Occurs in derived instances, where we just
212 -- refer directly to the right method
213 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
214 -- NB: qualified names are rejected by the parser
215 lookupImportedName rdr_name
217 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
218 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
220 --------------------------------------------------
222 --------------------------------------------------
224 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
225 lookupLocatedOccRn = wrapLocM lookupOccRn
227 -- lookupOccRn looks up an occurrence of a RdrName
228 lookupOccRn :: RdrName -> RnM Name
230 = getLocalRdrEnv `thenM` \ local_env ->
231 case lookupLocalRdrEnv local_env rdr_name of
232 Just name -> returnM name
233 Nothing -> lookupGlobalOccRn rdr_name
235 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
236 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
238 lookupGlobalOccRn :: RdrName -> RnM Name
239 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
240 -- environment. It's used only for
241 -- record field names
242 -- class op names in class and instance decls
244 lookupGlobalOccRn rdr_name
245 | not (isSrcRdrName rdr_name)
246 = lookupImportedName rdr_name
249 = -- First look up the name in the normal environment.
250 lookupGreRn rdr_name `thenM` \ mb_gre ->
252 Just gre -> returnM (gre_name gre) ;
255 -- We allow qualified names on the command line to refer to
256 -- *any* name exported by any module in scope, just as if
257 -- there was an "import qualified M" declaration for every
259 getModule `thenM` \ mod ->
260 if isQual rdr_name && mod == iNTERACTIVE then
261 -- This test is not expensive,
262 lookupQualifiedName rdr_name -- and only happens for failed lookups
264 unboundName rdr_name }
266 lookupImportedName :: RdrName -> TcRnIf m n Name
267 -- Lookup the occurrence of an imported name
268 -- The RdrName is *always* qualified or Exact
269 -- Treat it as an original name, and conjure up the Name
270 -- Usually it's Exact or Orig, but it can be Qual if it
271 -- comes from an hi-boot file. (This minor infelicity is
272 -- just to reduce duplication in the parser.)
273 lookupImportedName rdr_name
274 | Just n <- isExact_maybe rdr_name
275 -- This happens in derived code
278 | otherwise -- Always Orig, even when reading a .hi-boot file
279 = ASSERT( not (isUnqual rdr_name) )
280 lookupOrig (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
282 unboundName :: RdrName -> RnM Name
284 = do { addErr (unknownNameErr rdr_name)
285 ; env <- getGlobalRdrEnv;
286 ; traceRn (vcat [unknownNameErr rdr_name,
287 ptext SLIT("Global envt is:"),
288 nest 3 (pprGlobalRdrEnv env)])
289 ; returnM (mkUnboundName rdr_name) }
291 --------------------------------------------------
292 -- Lookup in the Global RdrEnv of the module
293 --------------------------------------------------
295 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
296 -- No filter function; does not report an error on failure
297 lookupSrcOcc_maybe rdr_name
298 = do { mb_gre <- lookupGreRn rdr_name
300 Nothing -> returnM Nothing
301 Just gre -> returnM (Just (gre_name gre)) }
303 -------------------------
304 lookupGreRn :: RdrName -> RnM (Maybe GlobalRdrElt)
305 -- Just look up the RdrName in the GlobalRdrEnv
307 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
309 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
310 -- Similar, but restricted to locally-defined things
311 lookupGreLocalRn rdr_name
312 = lookupGreRn_help rdr_name lookup_fn
314 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
316 lookupGreRn_help :: RdrName -- Only used in error message
317 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
318 -> RnM (Maybe GlobalRdrElt)
319 -- Checks for exactly one match; reports deprecations
320 -- Returns Nothing, without error, if too few
321 lookupGreRn_help rdr_name lookup
322 = do { env <- getGlobalRdrEnv
324 [] -> returnM Nothing
325 [gre] -> returnM (Just gre)
326 gres -> do { addNameClashErrRn rdr_name gres
327 ; returnM (Just (head gres)) } }
329 ------------------------------
331 ------------------------------
333 -- A qualified name on the command line can refer to any module at all: we
334 -- try to load the interface if we don't already have it.
335 lookupQualifiedName :: RdrName -> RnM Name
336 lookupQualifiedName rdr_name
338 mod = rdrNameModule rdr_name
339 occ = rdrNameOcc rdr_name
341 -- Note: we want to behave as we would for a source file import here,
342 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
343 loadSrcInterface doc mod False `thenM` \ iface ->
346 (mod,avails) <- mi_exports iface,
348 name <- availNames avail,
350 ((mod,occ):ns) -> ASSERT (null ns)
352 _ -> unboundName rdr_name
354 doc = ptext SLIT("Need to find") <+> ppr rdr_name
357 %*********************************************************
361 %*********************************************************
364 lookupTopFixSigNames :: RdrName -> RnM [Name]
365 -- GHC extension: look up both the tycon and data con
366 -- for con-like things
367 lookupTopFixSigNames rdr_name
368 | Just n <- isExact_maybe rdr_name
369 -- Special case for (:), which doesn't get into the GlobalRdrEnv
370 = return [n] -- For this we don't need to try the tycon too
372 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
373 ; return [gre_name gre | Just gre <- mb_gres] }
375 --------------------------------
376 bindLocalFixities :: [FixitySig RdrName] -> RnM a -> RnM a
377 -- Used for nested fixity decls
378 -- No need to worry about type constructors here,
379 -- Should check for duplicates but we don't
380 bindLocalFixities fixes thing_inside
381 | null fixes = thing_inside
382 | otherwise = mappM rn_sig fixes `thenM` \ new_bit ->
383 extendFixityEnv new_bit thing_inside
385 rn_sig (FixitySig lv@(L loc v) fix)
386 = addLocM lookupBndrRn lv `thenM` \ new_v ->
387 returnM (new_v, (FixItem (rdrNameOcc v) fix loc))
390 --------------------------------
391 lookupFixity is a bit strange.
393 * Nested local fixity decls are put in the local fixity env, which we
394 find with getFixtyEnv
396 * Imported fixities are found in the HIT or PIT
398 * Top-level fixity decls in this module may be for Names that are
399 either Global (constructors, class operations)
400 or Local/Exported (everything else)
401 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
402 We put them all in the local fixity environment
405 lookupFixityRn :: Name -> RnM Fixity
407 = getModule `thenM` \ this_mod ->
408 if nameIsLocalOrFrom this_mod name
409 then -- It's defined in this module
410 getFixityEnv `thenM` \ local_fix_env ->
411 traceRn (text "lookupFixityRn" <+> (ppr name $$ ppr local_fix_env)) `thenM_`
412 returnM (lookupFixity local_fix_env name)
414 else -- It's imported
415 -- For imported names, we have to get their fixities by doing a
416 -- loadHomeInterface, and consulting the Ifaces that comes back
417 -- from that, because the interface file for the Name might not
418 -- have been loaded yet. Why not? Suppose you import module A,
419 -- which exports a function 'f', thus;
420 -- module CurrentModule where
422 -- module A( f ) where
424 -- Then B isn't loaded right away (after all, it's possible that
425 -- nothing from B will be used). When we come across a use of
426 -- 'f', we need to know its fixity, and it's then, and only
427 -- then, that we load B.hi. That is what's happening here.
429 -- loadHomeInterface will find B.hi even if B is a hidden module,
430 -- and that's what we want.
431 initIfaceTcRn (loadHomeInterface doc name) `thenM` \ iface ->
432 returnM (mi_fix_fn iface (nameOccName name))
434 doc = ptext SLIT("Checking fixity for") <+> ppr name
436 dataTcOccs :: RdrName -> [RdrName]
437 -- If the input is a data constructor, return both it and a type
438 -- constructor. This is useful when we aren't sure which we are
441 | Just n <- isExact_maybe rdr_name -- Ghastly special case
442 , n `hasKey` consDataConKey = [rdr_name] -- see note below
443 | isDataOcc occ = [rdr_name_tc, rdr_name]
444 | otherwise = [rdr_name]
446 occ = rdrNameOcc rdr_name
447 rdr_name_tc = setRdrNameSpace rdr_name tcName
449 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
450 -- and setRdrNameSpace generates an Orig, which is fine
451 -- But it's not fine for (:), because there *is* no corresponding type
452 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
453 -- appear to be in scope (because Orig's simply allocate a new name-cache
454 -- entry) and then we get an error when we use dataTcOccs in
455 -- TcRnDriver.tcRnGetInfo. Large sigh.
458 %************************************************************************
461 Dealing with rebindable syntax is driven by the
462 Opt_NoImplicitPrelude dynamic flag.
464 In "deriving" code we don't want to use rebindable syntax
465 so we switch off the flag locally
468 %************************************************************************
470 Haskell 98 says that when you say "3" you get the "fromInteger" from the
471 Standard Prelude, regardless of what is in scope. However, to experiment
472 with having a language that is less coupled to the standard prelude, we're
473 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
474 happens to be in scope. Then you can
476 import MyPrelude as Prelude
477 to get the desired effect.
479 At the moment this just happens for
480 * fromInteger, fromRational on literals (in expressions and patterns)
481 * negate (in expressions)
482 * minus (arising from n+k patterns)
485 We store the relevant Name in the HsSyn tree, in
486 * HsIntegral/HsFractional
490 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
491 fromRationalName etc), but the renamer changes this to the appropriate user
492 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
494 We treat the orignal (standard) names as free-vars too, because the type checker
495 checks the type of the user thing against the type of the standard thing.
498 lookupSyntaxName :: Name -- The standard name
499 -> RnM (Name, FreeVars) -- Possibly a non-standard name
500 lookupSyntaxName std_name
501 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
502 if implicit_prelude then normal_case
504 -- Get the similarly named thing from the local environment
505 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
506 returnM (usr_name, unitFV usr_name)
508 normal_case = returnM (std_name, emptyFVs)
510 lookupSyntaxNames :: [Name] -- Standard names
511 -> RnM (ReboundNames Name, FreeVars) -- See comments with HsExpr.ReboundNames
512 lookupSyntaxNames std_names
513 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
514 if implicit_prelude then normal_case
516 -- Get the similarly named thing from the local environment
517 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
519 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
521 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
525 %*********************************************************
529 %*********************************************************
532 newLocalsRn :: [Located RdrName] -> RnM [Name]
533 newLocalsRn rdr_names_w_loc
534 = newUniqueSupply `thenM` \ us ->
535 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
537 mk (L loc rdr_name) uniq
538 | Just name <- isExact_maybe rdr_name = name
539 -- This happens in code generated by Template Haskell
540 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
541 -- We only bind unqualified names here
542 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
543 mkInternalName uniq (rdrNameOcc rdr_name) (srcSpanStart loc)
545 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
549 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
550 = -- Check for duplicate names
551 checkDupNames doc_str rdr_names_w_loc `thenM_`
553 -- Warn about shadowing, but only in source modules
554 ifOptM Opt_WarnNameShadowing
555 (checkShadowing doc_str rdr_names_w_loc) `thenM_`
557 -- Make fresh Names and extend the environment
558 newLocalsRn rdr_names_w_loc `thenM` \ names ->
559 getLocalRdrEnv `thenM` \ local_env ->
560 setLocalRdrEnv (extendLocalRdrEnv local_env names)
561 (enclosed_scope names)
564 bindLocalNames :: [Name] -> RnM a -> RnM a
565 bindLocalNames names enclosed_scope
566 = getLocalRdrEnv `thenM` \ name_env ->
567 setLocalRdrEnv (extendLocalRdrEnv name_env names)
570 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
571 bindLocalNamesFV names enclosed_scope
572 = do { (result, fvs) <- bindLocalNames names enclosed_scope
573 ; returnM (result, delListFromNameSet fvs names) }
576 -------------------------------------
577 -- binLocalsFVRn is the same as bindLocalsRn
578 -- except that it deals with free vars
579 bindLocatedLocalsFV :: SDoc -> [Located RdrName] -> ([Name] -> RnM (a,FreeVars))
581 bindLocatedLocalsFV doc rdr_names enclosed_scope
582 = bindLocatedLocalsRn doc rdr_names $ \ names ->
583 enclosed_scope names `thenM` \ (thing, fvs) ->
584 returnM (thing, delListFromNameSet fvs names)
586 -------------------------------------
587 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
588 -> ([LHsTyVarBndr Name] -> RnM a)
590 -- Haskell-98 binding of type variables; e.g. within a data type decl
591 bindTyVarsRn doc_str tyvar_names enclosed_scope
593 located_tyvars = hsLTyVarLocNames tyvar_names
595 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
596 enclosed_scope (zipWith replace tyvar_names names)
598 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
600 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
601 -- Find the type variables in the pattern type
602 -- signatures that must be brought into scope
603 bindPatSigTyVars tys thing_inside
604 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
605 ; if not scoped_tyvars then
608 do { name_env <- getLocalRdrEnv
609 ; let locd_tvs = [ tv | ty <- tys
610 , tv <- extractHsTyRdrTyVars ty
611 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
612 nubbed_tvs = nubBy eqLocated locd_tvs
613 -- The 'nub' is important. For example:
614 -- f (x :: t) (y :: t) = ....
615 -- We don't want to complain about binding t twice!
617 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
619 doc_sig = text "In a pattern type-signature"
621 bindPatSigTyVarsFV :: [LHsType RdrName]
624 bindPatSigTyVarsFV tys thing_inside
625 = bindPatSigTyVars tys $ \ tvs ->
626 thing_inside `thenM` \ (result,fvs) ->
627 returnM (result, fvs `delListFromNameSet` tvs)
629 bindSigTyVarsFV :: [LSig Name]
632 -- Bind the top-level forall'd type variables in the sigs.
635 -- The 'a' scopes over the rhs
637 -- NB: there'll usually be just one (for a function binding)
638 -- but if there are many, one may shadow the rest; too bad!
639 -- e.g x :: [a] -> [a]
642 -- In e, 'a' will be in scope, and it'll be the one from 'y'!
643 bindSigTyVarsFV sigs thing_inside
644 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
645 ; if not scoped_tyvars then
648 bindLocalNamesFV tvs thing_inside }
650 tvs = [ hsLTyVarName ltv
651 | L _ (Sig _ (L _ (HsForAllTy Explicit ltvs _ _))) <- sigs, ltv <- ltvs ]
652 -- Note the pattern-match on "Explicit"; we only bind
653 -- type variables from signatures with an explicit top-level for-all
656 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
657 -- This function is used only in rnSourceDecl on InstDecl
658 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
660 -------------------------------------
661 checkDupNames :: SDoc
664 checkDupNames doc_str rdr_names_w_loc
665 = -- Check for duplicated names in a binding group
666 mappM_ (dupNamesErr doc_str) dups
668 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
670 -------------------------------------
671 checkShadowing doc_str loc_rdr_names
672 = getLocalRdrEnv `thenM` \ local_env ->
673 getGlobalRdrEnv `thenM` \ global_env ->
675 check_shadow (L loc rdr_name)
676 | rdr_name `elemLocalRdrEnv` local_env
677 || not (null (lookupGRE_RdrName rdr_name global_env ))
678 = setSrcSpan loc $ addWarn (shadowedNameWarn doc_str rdr_name)
679 | otherwise = returnM ()
681 mappM_ check_shadow loc_rdr_names
685 %************************************************************************
687 \subsection{Free variable manipulation}
689 %************************************************************************
693 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
695 (ys, fvs_s) = unzip stuff
697 returnM (ys, plusFVs fvs_s)
701 %************************************************************************
703 \subsection{Envt utility functions}
705 %************************************************************************
708 warnUnusedModules :: [(Module,SrcSpan)] -> RnM ()
709 warnUnusedModules mods
710 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
712 bleat (mod,loc) = setSrcSpan loc $ addWarn (mk_warn mod)
713 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m) <+>
714 text "is imported, but nothing from it is used",
715 parens (ptext SLIT("except perhaps instances visible in") <+>
718 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
719 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
720 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
722 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM ()
723 warnUnusedLocalBinds names = ifOptM Opt_WarnUnusedBinds (warnUnusedLocals names)
724 warnUnusedMatches names = ifOptM Opt_WarnUnusedMatches (warnUnusedLocals names)
726 -------------------------
729 = warnUnusedBinds [(n,Just p) | GRE {gre_name = n, gre_prov = p} <- gres]
731 warnUnusedLocals names
732 = warnUnusedBinds [(n,Nothing) | n<-names]
734 warnUnusedBinds :: [(Name,Maybe Provenance)] -> RnM ()
735 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
736 where reportable (name,_) = reportIfUnused (nameOccName name)
738 -------------------------
740 warnUnusedName :: (Name, Maybe Provenance) -> RnM ()
741 warnUnusedName (name, prov)
744 nest 2 $ occNameFlavour (nameOccName name) <+> quotes (ppr name)]
745 -- TODO should be a proper span
747 (loc,msg) = case prov of
748 Just (Imported is _) ->
749 ( is_loc (head is), imp_from (is_mod imp_spec) )
753 ( srcLocSpan (nameSrcLoc name), unused_msg )
755 unused_msg = text "Defined but not used"
756 imp_from mod = text "Imported from" <+> quotes (ppr mod) <+> text "but not used"
760 addNameClashErrRn rdr_name (np1:nps)
761 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
762 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
764 msg1 = ptext SLIT("either") <+> mk_ref np1
765 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
766 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
768 shadowedNameWarn doc shadow
769 = hsep [ptext SLIT("This binding for"),
771 ptext SLIT("shadows an existing binding")]
774 unknownNameErr rdr_name
775 = sep [ptext SLIT("Not in scope:"),
776 nest 2 $ occNameFlavour (rdrNameOcc rdr_name) <+> quotes (ppr rdr_name)]
778 unknownInstBndrErr cls op
779 = quotes (ppr op) <+> ptext SLIT("is not a (visible) method of class") <+> quotes (ppr cls)
782 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
783 -- The rdrNameOcc is because we don't want to print Prelude.(,)
785 dupNamesErr :: SDoc -> [Located RdrName] -> RnM ()
786 dupNamesErr descriptor located_names
787 = setSrcSpan big_loc $
788 addErr (vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr name1),
792 L _ name1 = head located_names
793 locs = map getLoc located_names
794 big_loc = foldr1 combineSrcSpans locs
795 one_line = srcSpanStartLine big_loc == srcSpanEndLine big_loc
796 locations | one_line = empty
797 | otherwise = ptext SLIT("Bound at:") <+>
798 vcat (map ppr (sortLe (<=) locs))