2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
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,
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 ( loadInterfaceForName, loadSrcInterface )
34 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
35 import HsSyn ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
36 LHsTyVarBndr, LHsType,
37 Fixity, hsLTyVarLocNames, replaceTyVarName )
38 import RdrHsSyn ( extractHsTyRdrTyVars )
39 import RdrName ( RdrName, isQual, isUnqual, isOrig_maybe,
41 mkRdrUnqual, setRdrNameSpace, rdrNameOcc,
42 pprGlobalRdrEnv, lookupGRE_RdrName,
43 isExact_maybe, isSrcRdrName,
44 GlobalRdrElt(..), GlobalRdrEnv, lookupGlobalRdrEnv,
45 isLocalGRE, extendLocalRdrEnv, elemLocalRdrEnv, lookupLocalRdrEnv,
46 Provenance(..), pprNameProvenance,
47 importSpecLoc, importSpecModule
49 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity )
51 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
52 nameSrcLoc, nameOccName, nameModule, nameParent, isExternalName )
54 import OccName ( tcName, isDataOcc, pprNonVarNameSpace, occNameSpace,
56 import Module ( Module, ModuleName )
57 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, consDataConKey, hasKey )
59 import BasicTypes ( IPName, mapIPName )
60 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
61 srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
63 import Util ( sortLe )
64 import ListSetOps ( removeDups )
70 %*********************************************************
74 %*********************************************************
77 newTopSrcBinder :: Module -> Maybe Name -> Located RdrName -> RnM Name
78 newTopSrcBinder this_mod mb_parent (L loc rdr_name)
79 | Just name <- isExact_maybe rdr_name
80 = -- This is here to catch
81 -- (a) Exact-name binders created by Template Haskell
82 -- (b) The PrelBase defn of (say) [] and similar, for which
83 -- the parser reads the special syntax and returns an Exact RdrName
84 -- We are at a binding site for the name, so check first that it
85 -- the current module is the correct one; otherwise GHC can get
86 -- very confused indeed. This test rejects code like
87 -- data T = (,) Int Int
88 -- unless we are in GHC.Tup
89 ASSERT2( isExternalName name, ppr name )
90 do { checkM (this_mod == nameModule name)
91 (addErrAt loc (badOrigBinding rdr_name))
95 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
96 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
97 (addErrAt loc (badOrigBinding rdr_name))
98 -- When reading External Core we get Orig names as binders,
99 -- but they should agree with the module gotten from the monad
101 -- We can get built-in syntax showing up here too, sadly. If you type
103 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
104 -- uses setRdrNameSpace to make it into a data constructors. At that point
105 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
106 -- Hence the badOrigBinding error message.
108 -- Except for the ":Main.main = ..." definition inserted into
109 -- the Main module; ugh!
111 -- Because of this latter case, we call newGlobalBinder with a module from
112 -- the RdrName, not from the environment. In principle, it'd be fine to
113 -- have an arbitrary mixture of external core definitions in a single module,
114 -- (apart from module-initialisation issues, perhaps).
115 ; newGlobalBinder rdr_mod rdr_occ mb_parent (srcSpanStart loc) }
116 --TODO, should pass the whole span
119 = do { checkM (not (isQual rdr_name))
120 (addErrAt loc (badQualBndrErr rdr_name))
121 -- Binders should not be qualified; if they are, and with a different
122 -- module name, we we get a confusing "M.T is not in scope" error later
123 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) mb_parent (srcSpanStart loc) }
126 %*********************************************************
128 Source code occurrences
130 %*********************************************************
132 Looking up a name in the RnEnv.
135 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
136 lookupLocatedBndrRn = wrapLocM lookupBndrRn
138 lookupBndrRn :: RdrName -> RnM Name
139 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
140 lookupBndrRn rdr_name
141 = getLocalRdrEnv `thenM` \ local_env ->
142 case lookupLocalRdrEnv local_env rdr_name of
143 Just name -> returnM name
144 Nothing -> lookupTopBndrRn rdr_name
146 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
147 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
149 lookupTopBndrRn :: RdrName -> RnM Name
150 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
151 -- and there may be several imported 'f's too, which must not confuse us.
152 -- For example, this is OK:
154 -- infix 9 f -- The 'f' here does not need to be qualified
155 -- f x = x -- Nor here, of course
156 -- So we have to filter out the non-local ones.
158 -- A separate function (importsFromLocalDecls) reports duplicate top level
159 -- decls, so here it's safe just to choose an arbitrary one.
161 -- There should never be a qualified name in a binding position in Haskell,
162 -- but there can be if we have read in an external-Core file.
163 -- The Haskell parser checks for the illegal qualified name in Haskell
164 -- source files, so we don't need to do so here.
166 lookupTopBndrRn rdr_name
167 | Just name <- isExact_maybe rdr_name
170 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
171 -- This deals with the case of derived bindings, where
172 -- we don't bother to call newTopSrcBinder first
173 -- We assume there is no "parent" name
174 = do { loc <- getSrcSpanM
175 ; newGlobalBinder rdr_mod rdr_occ Nothing (srcSpanStart loc) }
178 = do { mb_gre <- lookupGreLocalRn rdr_name
180 Nothing -> unboundName rdr_name
181 Just gre -> returnM (gre_name gre) }
183 -- lookupLocatedSigOccRn is used for type signatures and pragmas
189 -- It's clear that the 'f' in the signature must refer to A.f
190 -- The Haskell98 report does not stipulate this, but it will!
191 -- So we must treat the 'f' in the signature in the same way
192 -- as the binding occurrence of 'f', using lookupBndrRn
193 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
194 lookupLocatedSigOccRn = lookupLocatedBndrRn
196 -- lookupInstDeclBndr is used for the binders in an
197 -- instance declaration. Here we use the class name to
200 lookupLocatedInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
201 lookupLocatedInstDeclBndr cls = wrapLocM (lookupInstDeclBndr cls)
203 lookupInstDeclBndr :: Name -> RdrName -> RnM Name
204 lookupInstDeclBndr cls_name rdr_name
205 | isUnqual rdr_name -- Find all the things the rdr-name maps to
206 = do { -- and pick the one with the right parent name
207 let { is_op gre = cls_name == nameParent (gre_name gre)
208 ; occ = rdrNameOcc rdr_name
209 ; lookup_fn env = filter is_op (lookupGlobalRdrEnv env occ) }
210 ; mb_gre <- lookupGreRn_help rdr_name lookup_fn
212 Just gre -> return (gre_name gre)
213 Nothing -> do { addErr (unknownInstBndrErr cls_name rdr_name)
214 ; return (mkUnboundName rdr_name) } }
216 | otherwise -- Occurs in derived instances, where we just
217 -- refer directly to the right method
218 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
219 -- NB: qualified names are rejected by the parser
220 lookupImportedName rdr_name
222 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
223 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
225 -- Looking up family names in type instances is a subtle affair. The family
226 -- may be imported, in which case we need to lookup the occurence of a global
227 -- name. Alternatively, the family may be in the same binding group (and in
228 -- fact in a declaration processed later), and we need to create a new top
231 -- So, also this is strictly speaking an occurence, we cannot raise an error
232 -- message yet for instances without a family declaration. This will happen
233 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
235 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
236 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
237 | not (isSrcRdrName rdr_name)
238 = lookupImportedName rdr_name
241 = -- First look up the name in the normal environment.
242 lookupGreRn rdr_name `thenM` \ mb_gre ->
244 Just gre -> returnM (gre_name gre) ;
245 Nothing -> newTopSrcBinder mod Nothing lrdr_name }
247 --------------------------------------------------
249 --------------------------------------------------
251 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
252 lookupLocatedOccRn = wrapLocM lookupOccRn
254 -- lookupOccRn looks up an occurrence of a RdrName
255 lookupOccRn :: RdrName -> RnM Name
257 = getLocalRdrEnv `thenM` \ local_env ->
258 case lookupLocalRdrEnv local_env rdr_name of
259 Just name -> returnM name
260 Nothing -> lookupGlobalOccRn rdr_name
262 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
263 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
265 lookupGlobalOccRn :: RdrName -> RnM Name
266 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
267 -- environment. It's used only for
268 -- record field names
269 -- class op names in class and instance decls
271 lookupGlobalOccRn rdr_name
272 | not (isSrcRdrName rdr_name)
273 = lookupImportedName rdr_name
276 = -- First look up the name in the normal environment.
277 lookupGreRn rdr_name `thenM` \ mb_gre ->
279 Just gre -> returnM (gre_name gre) ;
282 -- We allow qualified names on the command line to refer to
283 -- *any* name exported by any module in scope, just as if
284 -- there was an "import qualified M" declaration for every
286 getModule `thenM` \ mod ->
287 if isQual rdr_name && mod == iNTERACTIVE then
288 -- This test is not expensive,
289 lookupQualifiedName rdr_name -- and only happens for failed lookups
291 unboundName rdr_name }
293 lookupImportedName :: RdrName -> TcRnIf m n Name
294 -- Lookup the occurrence of an imported name
295 -- The RdrName is *always* qualified or Exact
296 -- Treat it as an original name, and conjure up the Name
297 -- Usually it's Exact or Orig, but it can be Qual if it
298 -- comes from an hi-boot file. (This minor infelicity is
299 -- just to reduce duplication in the parser.)
300 lookupImportedName rdr_name
301 | Just n <- isExact_maybe rdr_name
302 -- This happens in derived code
305 -- Always Orig, even when reading a .hi-boot file
306 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
307 = lookupOrig rdr_mod rdr_occ
310 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
312 unboundName :: RdrName -> RnM Name
314 = do { addErr (unknownNameErr rdr_name)
315 ; env <- getGlobalRdrEnv;
316 ; traceRn (vcat [unknownNameErr rdr_name,
317 ptext SLIT("Global envt is:"),
318 nest 3 (pprGlobalRdrEnv env)])
319 ; returnM (mkUnboundName rdr_name) }
321 --------------------------------------------------
322 -- Lookup in the Global RdrEnv of the module
323 --------------------------------------------------
325 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
326 -- No filter function; does not report an error on failure
327 lookupSrcOcc_maybe rdr_name
328 = do { mb_gre <- lookupGreRn rdr_name
330 Nothing -> returnM Nothing
331 Just gre -> returnM (Just (gre_name gre)) }
333 -------------------------
334 lookupGreRn :: RdrName -> RnM (Maybe GlobalRdrElt)
335 -- Just look up the RdrName in the GlobalRdrEnv
337 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
339 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
340 -- Similar, but restricted to locally-defined things
341 lookupGreLocalRn rdr_name
342 = lookupGreRn_help rdr_name lookup_fn
344 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
346 lookupGreRn_help :: RdrName -- Only used in error message
347 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
348 -> RnM (Maybe GlobalRdrElt)
349 -- Checks for exactly one match; reports deprecations
350 -- Returns Nothing, without error, if too few
351 lookupGreRn_help rdr_name lookup
352 = do { env <- getGlobalRdrEnv
354 [] -> returnM Nothing
355 [gre] -> returnM (Just gre)
356 gres -> do { addNameClashErrRn rdr_name gres
357 ; returnM (Just (head gres)) } }
359 ------------------------------
361 ------------------------------
363 -- A qualified name on the command line can refer to any module at all: we
364 -- try to load the interface if we don't already have it.
365 lookupQualifiedName :: RdrName -> RnM Name
366 lookupQualifiedName rdr_name
367 | Just (mod,occ) <- isQual_maybe rdr_name
368 -- Note: we want to behave as we would for a source file import here,
369 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
370 = loadSrcInterface doc mod False `thenM` \ iface ->
373 (mod,avails) <- mi_exports iface,
375 name <- availNames avail,
377 ((mod,occ):ns) -> ASSERT (null ns)
379 _ -> unboundName rdr_name
382 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
384 doc = ptext SLIT("Need to find") <+> ppr rdr_name
387 %*********************************************************
391 %*********************************************************
394 lookupLocalDataTcNames :: RdrName -> RnM [Name]
395 -- GHC extension: look up both the tycon and data con
396 -- for con-like things
397 -- Complain if neither is in scope
398 lookupLocalDataTcNames rdr_name
399 | Just n <- isExact_maybe rdr_name
400 -- Special case for (:), which doesn't get into the GlobalRdrEnv
401 = return [n] -- For this we don't need to try the tycon too
403 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
404 ; case [gre_name gre | Just gre <- mb_gres] of
405 [] -> do { addErr (unknownNameErr rdr_name)
407 names -> return names
410 --------------------------------
411 bindLocalFixities :: [FixitySig RdrName] -> RnM a -> RnM a
412 -- Used for nested fixity decls
413 -- No need to worry about type constructors here,
414 -- Should check for duplicates but we don't
415 bindLocalFixities fixes thing_inside
416 | null fixes = thing_inside
417 | otherwise = mappM rn_sig fixes `thenM` \ new_bit ->
418 extendFixityEnv new_bit thing_inside
420 rn_sig (FixitySig lv@(L loc v) fix)
421 = addLocM lookupBndrRn lv `thenM` \ new_v ->
422 returnM (new_v, (FixItem (rdrNameOcc v) fix loc))
425 --------------------------------
426 lookupFixity is a bit strange.
428 * Nested local fixity decls are put in the local fixity env, which we
429 find with getFixtyEnv
431 * Imported fixities are found in the HIT or PIT
433 * Top-level fixity decls in this module may be for Names that are
434 either Global (constructors, class operations)
435 or Local/Exported (everything else)
436 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
437 We put them all in the local fixity environment
440 lookupFixityRn :: Name -> RnM Fixity
442 = getModule `thenM` \ this_mod ->
443 if nameIsLocalOrFrom this_mod name
444 then -- It's defined in this module
445 getFixityEnv `thenM` \ local_fix_env ->
446 traceRn (text "lookupFixityRn" <+> (ppr name $$ ppr local_fix_env)) `thenM_`
447 returnM (lookupFixity local_fix_env name)
449 else -- It's imported
450 -- For imported names, we have to get their fixities by doing a
451 -- loadInterfaceForName, and consulting the Ifaces that comes back
452 -- from that, because the interface file for the Name might not
453 -- have been loaded yet. Why not? Suppose you import module A,
454 -- which exports a function 'f', thus;
455 -- module CurrentModule where
457 -- module A( f ) where
459 -- Then B isn't loaded right away (after all, it's possible that
460 -- nothing from B will be used). When we come across a use of
461 -- 'f', we need to know its fixity, and it's then, and only
462 -- then, that we load B.hi. That is what's happening here.
464 -- loadInterfaceForName will find B.hi even if B is a hidden module,
465 -- and that's what we want.
466 loadInterfaceForName doc name `thenM` \ iface ->
467 returnM (mi_fix_fn iface (nameOccName name))
469 doc = ptext SLIT("Checking fixity for") <+> ppr name
472 lookupTyFixityRn :: Located Name -> RnM Fixity
473 lookupTyFixityRn (L loc n)
474 = do { glaExts <- doptM Opt_GlasgowExts
475 ; when (not glaExts) (addWarnAt loc (infixTyConWarn n))
479 dataTcOccs :: RdrName -> [RdrName]
480 -- If the input is a data constructor, return both it and a type
481 -- constructor. This is useful when we aren't sure which we are
484 | Just n <- isExact_maybe rdr_name -- Ghastly special case
485 , n `hasKey` consDataConKey = [rdr_name] -- see note below
486 | isDataOcc occ = [rdr_name_tc, rdr_name]
487 | otherwise = [rdr_name]
489 occ = rdrNameOcc rdr_name
490 rdr_name_tc = setRdrNameSpace rdr_name tcName
492 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
493 -- and setRdrNameSpace generates an Orig, which is fine
494 -- But it's not fine for (:), because there *is* no corresponding type
495 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
496 -- appear to be in scope (because Orig's simply allocate a new name-cache
497 -- entry) and then we get an error when we use dataTcOccs in
498 -- TcRnDriver.tcRnGetInfo. Large sigh.
501 %************************************************************************
504 Dealing with rebindable syntax is driven by the
505 Opt_NoImplicitPrelude dynamic flag.
507 In "deriving" code we don't want to use rebindable syntax
508 so we switch off the flag locally
511 %************************************************************************
513 Haskell 98 says that when you say "3" you get the "fromInteger" from the
514 Standard Prelude, regardless of what is in scope. However, to experiment
515 with having a language that is less coupled to the standard prelude, we're
516 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
517 happens to be in scope. Then you can
519 import MyPrelude as Prelude
520 to get the desired effect.
522 At the moment this just happens for
523 * fromInteger, fromRational on literals (in expressions and patterns)
524 * negate (in expressions)
525 * minus (arising from n+k patterns)
528 We store the relevant Name in the HsSyn tree, in
529 * HsIntegral/HsFractional
533 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
534 fromRationalName etc), but the renamer changes this to the appropriate user
535 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
537 We treat the orignal (standard) names as free-vars too, because the type checker
538 checks the type of the user thing against the type of the standard thing.
541 lookupSyntaxName :: Name -- The standard name
542 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
543 lookupSyntaxName std_name
544 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
545 if implicit_prelude then normal_case
547 -- Get the similarly named thing from the local environment
548 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
549 returnM (HsVar usr_name, unitFV usr_name)
551 normal_case = returnM (HsVar std_name, emptyFVs)
553 lookupSyntaxTable :: [Name] -- Standard names
554 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
555 lookupSyntaxTable std_names
556 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
557 if implicit_prelude then normal_case
559 -- Get the similarly named thing from the local environment
560 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
562 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
564 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
568 %*********************************************************
572 %*********************************************************
575 newLocalsRn :: [Located RdrName] -> RnM [Name]
576 newLocalsRn rdr_names_w_loc
577 = newUniqueSupply `thenM` \ us ->
578 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
580 mk (L loc rdr_name) uniq
581 | Just name <- isExact_maybe rdr_name = name
582 -- This happens in code generated by Template Haskell
583 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
584 -- We only bind unqualified names here
585 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
586 mkInternalName uniq (rdrNameOcc rdr_name) (srcSpanStart loc)
588 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
592 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
593 = -- Check for duplicate names
594 checkDupNames doc_str rdr_names_w_loc `thenM_`
596 -- Warn about shadowing, but only in source modules
597 ifOptM Opt_WarnNameShadowing
598 (checkShadowing doc_str rdr_names_w_loc) `thenM_`
600 -- Make fresh Names and extend the environment
601 newLocalsRn rdr_names_w_loc `thenM` \ names ->
602 getLocalRdrEnv `thenM` \ local_env ->
603 setLocalRdrEnv (extendLocalRdrEnv local_env names)
604 (enclosed_scope names)
607 bindLocalNames :: [Name] -> RnM a -> RnM a
608 bindLocalNames names enclosed_scope
609 = getLocalRdrEnv `thenM` \ name_env ->
610 setLocalRdrEnv (extendLocalRdrEnv name_env names)
613 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
614 bindLocalNamesFV names enclosed_scope
615 = do { (result, fvs) <- bindLocalNames names enclosed_scope
616 ; returnM (result, delListFromNameSet fvs names) }
619 -------------------------------------
620 -- binLocalsFVRn is the same as bindLocalsRn
621 -- except that it deals with free vars
622 bindLocatedLocalsFV :: SDoc -> [Located RdrName] -> ([Name] -> RnM (a,FreeVars))
624 bindLocatedLocalsFV doc rdr_names enclosed_scope
625 = bindLocatedLocalsRn doc rdr_names $ \ names ->
626 enclosed_scope names `thenM` \ (thing, fvs) ->
627 returnM (thing, delListFromNameSet fvs names)
629 -------------------------------------
630 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
631 -> ([LHsTyVarBndr Name] -> RnM a)
633 -- Haskell-98 binding of type variables; e.g. within a data type decl
634 bindTyVarsRn doc_str tyvar_names enclosed_scope
636 located_tyvars = hsLTyVarLocNames tyvar_names
638 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
639 enclosed_scope (zipWith replace tyvar_names names)
641 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
643 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
644 -- Find the type variables in the pattern type
645 -- signatures that must be brought into scope
646 bindPatSigTyVars tys thing_inside
647 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
648 ; if not scoped_tyvars then
651 do { name_env <- getLocalRdrEnv
652 ; let locd_tvs = [ tv | ty <- tys
653 , tv <- extractHsTyRdrTyVars ty
654 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
655 nubbed_tvs = nubBy eqLocated locd_tvs
656 -- The 'nub' is important. For example:
657 -- f (x :: t) (y :: t) = ....
658 -- We don't want to complain about binding t twice!
660 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
662 doc_sig = text "In a pattern type-signature"
664 bindPatSigTyVarsFV :: [LHsType RdrName]
667 bindPatSigTyVarsFV tys thing_inside
668 = bindPatSigTyVars tys $ \ tvs ->
669 thing_inside `thenM` \ (result,fvs) ->
670 returnM (result, fvs `delListFromNameSet` tvs)
672 bindSigTyVarsFV :: [Name]
675 bindSigTyVarsFV tvs thing_inside
676 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
677 ; if not scoped_tyvars then
680 bindLocalNamesFV tvs thing_inside }
682 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
683 -- This function is used only in rnSourceDecl on InstDecl
684 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
686 -------------------------------------
687 checkDupNames :: SDoc
690 checkDupNames doc_str rdr_names_w_loc
691 = -- Check for duplicated names in a binding group
692 mappM_ (dupNamesErr doc_str) dups
694 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
696 -------------------------------------
697 checkShadowing doc_str loc_rdr_names
698 = getLocalRdrEnv `thenM` \ local_env ->
699 getGlobalRdrEnv `thenM` \ global_env ->
701 check_shadow (L loc rdr_name)
702 | rdr_name `elemLocalRdrEnv` local_env
703 || not (null (lookupGRE_RdrName rdr_name global_env ))
704 = addWarnAt loc (shadowedNameWarn doc_str rdr_name)
705 | otherwise = returnM ()
707 mappM_ check_shadow loc_rdr_names
711 %************************************************************************
713 \subsection{Free variable manipulation}
715 %************************************************************************
719 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
721 (ys, fvs_s) = unzip stuff
723 returnM (ys, plusFVs fvs_s)
727 %************************************************************************
729 \subsection{Envt utility functions}
731 %************************************************************************
734 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
735 warnUnusedModules mods
736 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
738 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
739 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
740 <+> text "is imported, but nothing from it is used,",
741 nest 2 (ptext SLIT("except perhaps instances visible in")
743 ptext SLIT("To suppress this warning, use:")
744 <+> ptext SLIT("import") <+> ppr m <> parens empty ]
747 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
748 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
749 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
751 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM ()
752 warnUnusedLocalBinds names = ifOptM Opt_WarnUnusedBinds (warnUnusedLocals names)
753 warnUnusedMatches names = ifOptM Opt_WarnUnusedMatches (warnUnusedLocals names)
755 -------------------------
758 = warnUnusedBinds [(n,Just p) | GRE {gre_name = n, gre_prov = p} <- gres]
760 warnUnusedLocals names
761 = warnUnusedBinds [(n,Nothing) | n<-names]
763 warnUnusedBinds :: [(Name,Maybe Provenance)] -> RnM ()
764 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
765 where reportable (name,_)
766 | isWiredInName name = False -- Don't report unused wired-in names
767 -- Otherwise we get a zillion warnings
769 | otherwise = reportIfUnused (nameOccName name)
771 -------------------------
773 warnUnusedName :: (Name, Maybe Provenance) -> RnM ()
774 warnUnusedName (name, prov)
777 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
778 <+> quotes (ppr name)]
779 -- TODO should be a proper span
781 (loc,msg) = case prov of
783 -> (importSpecLoc imp_spec, imp_from (importSpecModule imp_spec))
786 other -> (srcLocSpan (nameSrcLoc name), unused_msg)
788 unused_msg = text "Defined but not used"
789 imp_from mod = text "Imported from" <+> quotes (ppr mod) <+> text "but not used"
793 addNameClashErrRn rdr_name names
794 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
795 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
798 msg1 = ptext SLIT("either") <+> mk_ref np1
799 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
800 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
802 shadowedNameWarn doc shadow
803 = hsep [ptext SLIT("This binding for"),
805 ptext SLIT("shadows an existing binding")]
808 unknownNameErr rdr_name
809 = sep [ptext SLIT("Not in scope:"),
810 nest 2 $ pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
811 <+> quotes (ppr rdr_name)]
813 unknownInstBndrErr cls op
814 = quotes (ppr op) <+> ptext SLIT("is not a (visible) method of class") <+> quotes (ppr cls)
817 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
818 -- The rdrNameOcc is because we don't want to print Prelude.(,)
820 dupNamesErr :: SDoc -> [Located RdrName] -> RnM ()
821 dupNamesErr descriptor located_names
823 vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr name1),
824 locations, descriptor]
826 L _ name1 = head located_names
827 locs = map getLoc located_names
828 big_loc = foldr1 combineSrcSpans locs
829 one_line = isOneLineSpan big_loc
830 locations | one_line = empty
831 | otherwise = ptext SLIT("Bound at:") <+>
832 vcat (map ppr (sortLe (<=) locs))
834 badQualBndrErr rdr_name
835 = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name
838 = vcat [ftext FSLIT("Accepting non-standard infix type constructor") <+> quotes (ppr op),
839 ftext FSLIT("Use -fglasgow-exts to avoid this warning")]