2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
4 \section[RnEnv]{Environment manipulation for the renamer monad}
8 -- The above warning supression flag is a temporary kludge.
9 -- While working on this module you are encouraged to remove it and fix
10 -- any warnings in the module. See
11 -- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
15 newTopSrcBinder, lookupFamInstDeclBndr,
16 lookupLocatedBndrRn, lookupBndrRn, lookupBndrRn_maybe,
17 lookupLocatedTopBndrRn, lookupTopBndrRn, lookupBndrRn_maybe,
18 lookupLocatedOccRn, lookupOccRn,
19 lookupLocatedGlobalOccRn, lookupGlobalOccRn,
20 lookupLocalDataTcNames, lookupSrcOcc_maybe,
21 lookupFixityRn, lookupTyFixityRn, lookupLocatedSigOccRn,
22 lookupInstDeclBndr, lookupRecordBndr, lookupConstructorFields,
23 lookupSyntaxName, lookupSyntaxTable, lookupImportedName,
24 lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
27 newLocalsRn, newIPNameRn,
28 bindLocalNames, bindLocalNamesFV, bindLocalNamesFV_WithFixities,
29 bindLocatedLocalsFV, bindLocatedLocalsRn,
30 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
31 bindTyVarsRn, extendTyVarEnvFVRn,
34 checkDupRdrNames, checkDupNames, checkShadowedNames,
35 checkDupAndShadowedRdrNames,
37 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
38 warnUnusedTopBinds, warnUnusedLocalBinds,
39 dataTcOccs, unknownNameErr,
42 #include "HsVersions.h"
44 import LoadIface ( loadInterfaceForName, loadSrcInterface )
45 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
46 import HsSyn ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
47 LHsTyVarBndr, LHsType,
48 Fixity, hsLTyVarLocNames, replaceTyVarName )
49 import RdrHsSyn ( extractHsTyRdrTyVars )
51 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity)
52 import TcEnv ( tcLookupDataCon )
54 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
55 nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
59 import DataCon ( dataConFieldLabels )
60 import OccName ( OccName, tcName, isDataOcc, pprNonVarNameSpace, occNameSpace,
61 reportIfUnused, occNameFS )
62 import Module ( Module, ModuleName )
63 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, consDataConKey, hasKey )
65 import BasicTypes ( IPName, mapIPName, Fixity )
66 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
67 srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
71 import ListSetOps ( removeDups )
78 %*********************************************************
82 %*********************************************************
85 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
86 newTopSrcBinder this_mod (L loc rdr_name)
87 | Just name <- isExact_maybe rdr_name
88 = -- This is here to catch
89 -- (a) Exact-name binders created by Template Haskell
90 -- (b) The PrelBase defn of (say) [] and similar, for which
91 -- the parser reads the special syntax and returns an Exact RdrName
92 -- We are at a binding site for the name, so check first that it
93 -- the current module is the correct one; otherwise GHC can get
94 -- very confused indeed. This test rejects code like
95 -- data T = (,) Int Int
96 -- unless we are in GHC.Tup
97 ASSERT2( isExternalName name, ppr name )
98 do { checkM (this_mod == nameModule name)
99 (addErrAt loc (badOrigBinding rdr_name))
103 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
104 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
105 (addErrAt loc (badOrigBinding rdr_name))
106 -- When reading External Core we get Orig names as binders,
107 -- but they should agree with the module gotten from the monad
109 -- We can get built-in syntax showing up here too, sadly. If you type
111 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
112 -- uses setRdrNameSpace to make it into a data constructors. At that point
113 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
114 -- Hence the badOrigBinding error message.
116 -- Except for the ":Main.main = ..." definition inserted into
117 -- the Main module; ugh!
119 -- Because of this latter case, we call newGlobalBinder with a module from
120 -- the RdrName, not from the environment. In principle, it'd be fine to
121 -- have an arbitrary mixture of external core definitions in a single module,
122 -- (apart from module-initialisation issues, perhaps).
123 ; newGlobalBinder rdr_mod rdr_occ loc }
124 --TODO, should pass the whole span
127 = do { checkM (not (isQual rdr_name))
128 (addErrAt loc (badQualBndrErr rdr_name))
129 -- Binders should not be qualified; if they are, and with a different
130 -- module name, we we get a confusing "M.T is not in scope" error later
131 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
134 %*********************************************************
136 Source code occurrences
138 %*********************************************************
140 Looking up a name in the RnEnv.
143 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
144 lookupLocatedBndrRn = wrapLocM lookupBndrRn
146 lookupBndrRn :: RdrName -> RnM Name
147 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
150 Nothing -> do traceRn $ text "lookupTopBndrRn"
153 lookupTopBndrRn :: RdrName -> RnM Name
154 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
157 Nothing -> do traceRn $ text "lookupTopBndrRn"
160 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
161 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
162 lookupBndrRn_maybe rdr_name
163 = getLocalRdrEnv `thenM` \ local_env ->
164 case lookupLocalRdrEnv local_env rdr_name of
165 Just name -> returnM (Just name)
166 Nothing -> lookupTopBndrRn_maybe rdr_name
168 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
169 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
171 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
172 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
173 -- and there may be several imported 'f's too, which must not confuse us.
174 -- For example, this is OK:
176 -- infix 9 f -- The 'f' here does not need to be qualified
177 -- f x = x -- Nor here, of course
178 -- So we have to filter out the non-local ones.
180 -- A separate function (importsFromLocalDecls) reports duplicate top level
181 -- decls, so here it's safe just to choose an arbitrary one.
183 -- There should never be a qualified name in a binding position in Haskell,
184 -- but there can be if we have read in an external-Core file.
185 -- The Haskell parser checks for the illegal qualified name in Haskell
186 -- source files, so we don't need to do so here.
188 lookupTopBndrRn_maybe rdr_name
189 | Just name <- isExact_maybe rdr_name
190 = returnM (Just name)
192 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
193 -- This deals with the case of derived bindings, where
194 -- we don't bother to call newTopSrcBinder first
195 -- We assume there is no "parent" name
196 = do { loc <- getSrcSpanM
197 ; n <- newGlobalBinder rdr_mod rdr_occ loc
201 = do { mb_gre <- lookupGreLocalRn rdr_name
203 Nothing -> returnM Nothing
204 Just gre -> returnM (Just $ gre_name gre) }
206 -- lookupLocatedSigOccRn is used for type signatures and pragmas
212 -- It's clear that the 'f' in the signature must refer to A.f
213 -- The Haskell98 report does not stipulate this, but it will!
214 -- So we must treat the 'f' in the signature in the same way
215 -- as the binding occurrence of 'f', using lookupBndrRn
217 -- However, consider this case:
221 -- We don't want to say 'f' is out of scope; instead, we want to
222 -- return the imported 'f', so that later on the reanamer will
223 -- correctly report "misplaced type sig".
224 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
225 lookupLocatedSigOccRn = wrapLocM $ \ rdr_name -> do
226 { local_env <- getLocalRdrEnv
227 ; case lookupLocalRdrEnv local_env rdr_name of {
230 { mb_gre <- lookupGreLocalRn rdr_name
232 Just gre -> return (gre_name gre)
233 Nothing -> lookupGlobalOccRn rdr_name
236 -----------------------------------------------
237 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
238 -- This is called on the method name on the left-hand side of an
239 -- instance declaration binding. eg. instance Functor T where
241 -- ^^^^ called on this
242 -- Regardless of how many unqualified fmaps are in scope, we want
243 -- the one that comes from the Functor class.
245 -- Furthermore, note that we take no account of whether the
246 -- name is only in scope qualified. I.e. even if method op is
247 -- in scope as M.op, we still allow plain 'op' on the LHS of
249 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
251 doc = ptext SLIT("method of class") <+> quotes (ppr cls)
252 is_op gre@(GRE {gre_par = ParentIs n}) = n == cls
255 -----------------------------------------------
256 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
257 -- Used for record construction and pattern matching
258 -- When the -fdisambiguate-record-fields flag is on, take account of the
259 -- constructor name to disambiguate which field to use; it's just the
260 -- same as for instance decls
261 lookupRecordBndr Nothing rdr_name
262 = lookupLocatedGlobalOccRn rdr_name
263 lookupRecordBndr (Just (L _ data_con)) rdr_name
264 = do { flag_on <- doptM Opt_DisambiguateRecordFields
266 then lookupLocatedGlobalOccRn rdr_name
268 fields <- lookupConstructorFields data_con
269 ; let is_field gre = gre_name gre `elem` fields
270 ; lookup_located_sub_bndr is_field doc rdr_name
273 doc = ptext SLIT("field of constructor") <+> quotes (ppr data_con)
276 lookupConstructorFields :: Name -> RnM [Name]
277 -- Look up the fields of a given constructor
278 -- * For constructors from this module, use the record field env,
279 -- which is itself gathered from the (as yet un-typechecked)
282 -- * For constructors from imported modules, use the *type* environment
283 -- since imported modles are already compiled, the info is conveniently
286 lookupConstructorFields con_name
287 = do { this_mod <- getModule
288 ; if nameIsLocalOrFrom this_mod con_name then
289 do { field_env <- getRecFieldEnv
290 ; return (lookupNameEnv field_env con_name `orElse` []) }
292 do { con <- tcLookupDataCon con_name
293 ; return (dataConFieldLabels con) } }
295 -----------------------------------------------
296 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
297 -> SDoc -> Located RdrName
298 -> RnM (Located Name)
299 lookup_located_sub_bndr is_good doc rdr_name
300 = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
302 lookup_sub_bndr is_good doc rdr_name
303 | isUnqual rdr_name -- Find all the things the rdr-name maps to
304 = do { -- and pick the one with the right parent name
305 ; env <- getGlobalRdrEnv
306 ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
307 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
308 -- The latter does pickGREs, but we want to allow 'x'
309 -- even if only 'M.x' is in scope
310 [gre] -> return (gre_name gre)
311 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
312 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
313 ; return (mkUnboundName rdr_name) }
314 gres -> do { addNameClashErrRn rdr_name gres
315 ; return (gre_name (head gres)) }
318 | otherwise -- Occurs in derived instances, where we just
319 -- refer directly to the right method
320 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
321 -- NB: qualified names are rejected by the parser
322 lookupImportedName rdr_name
324 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
325 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
327 -- Looking up family names in type instances is a subtle affair. The family
328 -- may be imported, in which case we need to lookup the occurence of a global
329 -- name. Alternatively, the family may be in the same binding group (and in
330 -- fact in a declaration processed later), and we need to create a new top
333 -- So, also this is strictly speaking an occurence, we cannot raise an error
334 -- message yet for instances without a family declaration. This will happen
335 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
337 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
338 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
339 = do { mb_gre <- lookupGreRn_maybe rdr_name
341 Just gre -> returnM (gre_name gre) ;
342 Nothing -> newTopSrcBinder mod lrdr_name }
344 --------------------------------------------------
346 --------------------------------------------------
348 getLookupOccRn :: RnM (Name -> Maybe Name)
350 = getLocalRdrEnv `thenM` \ local_env ->
351 return (lookupLocalRdrOcc local_env . nameOccName)
353 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
354 lookupLocatedOccRn = wrapLocM lookupOccRn
356 -- lookupOccRn looks up an occurrence of a RdrName
357 lookupOccRn :: RdrName -> RnM Name
359 = getLocalRdrEnv `thenM` \ local_env ->
360 case lookupLocalRdrEnv local_env rdr_name of
361 Just name -> returnM name
362 Nothing -> lookupGlobalOccRn rdr_name
364 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
365 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
367 lookupGlobalOccRn :: RdrName -> RnM Name
368 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
369 -- environment. It's used only for
370 -- record field names
371 -- class op names in class and instance decls
373 lookupGlobalOccRn rdr_name
374 | not (isSrcRdrName rdr_name)
375 = lookupImportedName rdr_name
378 = -- First look up the name in the normal environment.
379 lookupGreRn_maybe rdr_name `thenM` \ mb_gre ->
381 Just gre -> returnM (gre_name gre) ;
384 -- We allow qualified names on the command line to refer to
385 -- *any* name exported by any module in scope, just as if
386 -- there was an "import qualified M" declaration for every
388 getModule `thenM` \ mod ->
389 if isQual rdr_name && mod == iNTERACTIVE then
390 -- This test is not expensive,
391 lookupQualifiedName rdr_name -- and only happens for failed lookups
393 traceRn $ text "lookupGlobalOccRn"
394 unboundName rdr_name }
396 lookupImportedName :: RdrName -> TcRnIf m n Name
397 -- Lookup the occurrence of an imported name
398 -- The RdrName is *always* qualified or Exact
399 -- Treat it as an original name, and conjure up the Name
400 -- Usually it's Exact or Orig, but it can be Qual if it
401 -- comes from an hi-boot file. (This minor infelicity is
402 -- just to reduce duplication in the parser.)
403 lookupImportedName rdr_name
404 | Just n <- isExact_maybe rdr_name
405 -- This happens in derived code
408 -- Always Orig, even when reading a .hi-boot file
409 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
410 = lookupOrig rdr_mod rdr_occ
413 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
415 unboundName :: RdrName -> RnM Name
417 = do { addErr (unknownNameErr rdr_name)
418 ; env <- getGlobalRdrEnv;
419 ; traceRn (vcat [unknownNameErr rdr_name,
420 ptext SLIT("Global envt is:"),
421 nest 3 (pprGlobalRdrEnv env)])
422 ; returnM (mkUnboundName rdr_name) }
424 --------------------------------------------------
425 -- Lookup in the Global RdrEnv of the module
426 --------------------------------------------------
428 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
429 -- No filter function; does not report an error on failure
430 lookupSrcOcc_maybe rdr_name
431 = do { mb_gre <- lookupGreRn_maybe rdr_name
433 Nothing -> returnM Nothing
434 Just gre -> returnM (Just (gre_name gre)) }
436 -------------------------
437 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
438 -- Just look up the RdrName in the GlobalRdrEnv
439 lookupGreRn_maybe rdr_name
440 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
442 lookupGreRn :: RdrName -> RnM GlobalRdrElt
443 -- If not found, add error message, and return a fake GRE
445 = do { mb_gre <- lookupGreRn_maybe rdr_name
447 Just gre -> return gre ;
449 { traceRn $ text "lookupGreRn"
450 ; name <- unboundName rdr_name
451 ; return (GRE { gre_name = name, gre_par = NoParent,
452 gre_prov = LocalDef }) }}}
454 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
455 -- Similar, but restricted to locally-defined things
456 lookupGreLocalRn rdr_name
457 = lookupGreRn_help rdr_name lookup_fn
459 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
461 lookupGreRn_help :: RdrName -- Only used in error message
462 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
463 -> RnM (Maybe GlobalRdrElt)
464 -- Checks for exactly one match; reports deprecations
465 -- Returns Nothing, without error, if too few
466 lookupGreRn_help rdr_name lookup
467 = do { env <- getGlobalRdrEnv
469 [] -> returnM Nothing
470 [gre] -> returnM (Just gre)
471 gres -> do { addNameClashErrRn rdr_name gres
472 ; returnM (Just (head gres)) } }
474 ------------------------------
476 ------------------------------
478 -- A qualified name on the command line can refer to any module at all: we
479 -- try to load the interface if we don't already have it.
480 lookupQualifiedName :: RdrName -> RnM Name
481 lookupQualifiedName rdr_name
482 | Just (mod,occ) <- isQual_maybe rdr_name
483 -- Note: we want to behave as we would for a source file import here,
484 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
485 = loadSrcInterface doc mod False `thenM` \ iface ->
488 (mod,avails) <- mi_exports iface,
490 name <- availNames avail,
492 ((mod,occ):ns) -> ASSERT (null ns)
494 _ -> unboundName rdr_name
497 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
499 doc = ptext SLIT("Need to find") <+> ppr rdr_name
502 %*********************************************************
506 %*********************************************************
509 lookupLocalDataTcNames :: RdrName -> RnM [Name]
510 -- GHC extension: look up both the tycon and data con
511 -- for con-like things
512 -- Complain if neither is in scope
513 lookupLocalDataTcNames rdr_name
514 | Just n <- isExact_maybe rdr_name
515 -- Special case for (:), which doesn't get into the GlobalRdrEnv
516 = return [n] -- For this we don't need to try the tycon too
518 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
519 ; case [gre_name gre | Just gre <- mb_gres] of
521 -- run for error reporting
522 ; unboundName rdr_name
524 names -> return names
527 --------------------------------
528 bindLocalFixities :: [FixitySig RdrName] -> (UniqFM (Located Fixity) -> RnM a) -> RnM a
529 -- Used for nested fixity decls:
530 -- bind the names that are in scope already;
531 -- pass the rest to the continuation for later
532 -- as a FastString->(Located Fixity) map
534 -- No need to worry about type constructors here,
535 -- Should check for duplicates?
536 bindLocalFixities fixes thing_inside
537 | null fixes = thing_inside emptyUFM
538 | otherwise = do ls <- mappM rn_sig fixes
539 let (now, later) = nowAndLater ls
540 extendFixityEnv now $ thing_inside later
542 rn_sig (FixitySig lv@(L loc v) fix) = do
543 vopt <- lookupBndrRn_maybe v
545 Just new_v -> returnM (Left (new_v, (FixItem (rdrNameOcc v) fix)))
546 Nothing -> returnM (Right (occNameFS $ rdrNameOcc v, (L loc fix)))
548 nowAndLater :: [Either (Name, FixItem) (FastString, Located Fixity)]
549 -> ([(Name,FixItem)], UniqFM (Located Fixity))
551 foldr (\ cur -> \ (now, later) ->
553 Left (n, f) -> ((n, f) : now, later)
554 Right (fs, f) -> (now, addToUFM later fs f))
557 -- Used for nested fixity decls to bind names along with their fixities.
558 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
559 -- Also check for unused binders
560 bindLocalNamesFV_WithFixities :: [Name]
561 -> UniqFM (Located Fixity)
562 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
563 bindLocalNamesFV_WithFixities names fixities thing_inside
564 = bindLocalNamesFV names $
565 extendFixityEnv boundFixities $
568 -- find the names that have fixity decls
569 boundFixities = foldr
571 -- check whether this name has a fixity decl
572 case lookupUFM fixities (occNameFS (nameOccName name)) of
573 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
574 Nothing -> acc) [] names
575 -- bind the names; extend the fixity env; do the thing inside
578 --------------------------------
579 lookupFixity is a bit strange.
581 * Nested local fixity decls are put in the local fixity env, which we
582 find with getFixtyEnv
584 * Imported fixities are found in the HIT or PIT
586 * Top-level fixity decls in this module may be for Names that are
587 either Global (constructors, class operations)
588 or Local/Exported (everything else)
589 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
590 We put them all in the local fixity environment
593 lookupFixityRn :: Name -> RnM Fixity
595 = getModule `thenM` \ this_mod ->
596 if nameIsLocalOrFrom this_mod name
597 then do -- It's defined in this module
598 local_fix_env <- getFixityEnv
599 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
600 vcat [ppr name, ppr local_fix_env])
601 return $ lookupFixity local_fix_env name
602 else -- It's imported
603 -- For imported names, we have to get their fixities by doing a
604 -- loadInterfaceForName, and consulting the Ifaces that comes back
605 -- from that, because the interface file for the Name might not
606 -- have been loaded yet. Why not? Suppose you import module A,
607 -- which exports a function 'f', thus;
608 -- module CurrentModule where
610 -- module A( f ) where
612 -- Then B isn't loaded right away (after all, it's possible that
613 -- nothing from B will be used). When we come across a use of
614 -- 'f', we need to know its fixity, and it's then, and only
615 -- then, that we load B.hi. That is what's happening here.
617 -- loadInterfaceForName will find B.hi even if B is a hidden module,
618 -- and that's what we want.
619 loadInterfaceForName doc name `thenM` \ iface -> do {
620 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
621 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
622 returnM (mi_fix_fn iface (nameOccName name))
625 doc = ptext SLIT("Checking fixity for") <+> ppr name
628 lookupTyFixityRn :: Located Name -> RnM Fixity
629 lookupTyFixityRn (L loc n) = lookupFixityRn n
632 dataTcOccs :: RdrName -> [RdrName]
633 -- If the input is a data constructor, return both it and a type
634 -- constructor. This is useful when we aren't sure which we are
637 | Just n <- isExact_maybe rdr_name -- Ghastly special case
638 , n `hasKey` consDataConKey = [rdr_name] -- see note below
639 | isDataOcc occ = [rdr_name_tc, rdr_name]
640 | otherwise = [rdr_name]
642 occ = rdrNameOcc rdr_name
643 rdr_name_tc = setRdrNameSpace rdr_name tcName
645 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
646 -- and setRdrNameSpace generates an Orig, which is fine
647 -- But it's not fine for (:), because there *is* no corresponding type
648 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
649 -- appear to be in scope (because Orig's simply allocate a new name-cache
650 -- entry) and then we get an error when we use dataTcOccs in
651 -- TcRnDriver.tcRnGetInfo. Large sigh.
654 %************************************************************************
657 Dealing with rebindable syntax is driven by the
658 Opt_NoImplicitPrelude dynamic flag.
660 In "deriving" code we don't want to use rebindable syntax
661 so we switch off the flag locally
664 %************************************************************************
666 Haskell 98 says that when you say "3" you get the "fromInteger" from the
667 Standard Prelude, regardless of what is in scope. However, to experiment
668 with having a language that is less coupled to the standard prelude, we're
669 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
670 happens to be in scope. Then you can
672 import MyPrelude as Prelude
673 to get the desired effect.
675 At the moment this just happens for
676 * fromInteger, fromRational on literals (in expressions and patterns)
677 * negate (in expressions)
678 * minus (arising from n+k patterns)
681 We store the relevant Name in the HsSyn tree, in
682 * HsIntegral/HsFractional/HsIsString
686 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
687 fromRationalName etc), but the renamer changes this to the appropriate user
688 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
690 We treat the orignal (standard) names as free-vars too, because the type checker
691 checks the type of the user thing against the type of the standard thing.
694 lookupSyntaxName :: Name -- The standard name
695 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
696 lookupSyntaxName std_name
697 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
698 if implicit_prelude then normal_case
700 -- Get the similarly named thing from the local environment
701 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
702 returnM (HsVar usr_name, unitFV usr_name)
704 normal_case = returnM (HsVar std_name, emptyFVs)
706 lookupSyntaxTable :: [Name] -- Standard names
707 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
708 lookupSyntaxTable std_names
709 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
710 if implicit_prelude then normal_case
712 -- Get the similarly named thing from the local environment
713 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
715 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
717 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
721 %*********************************************************
725 %*********************************************************
728 newLocalsRn :: [Located RdrName] -> RnM [Name]
729 newLocalsRn rdr_names_w_loc
730 = newUniqueSupply `thenM` \ us ->
731 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
733 mk (L loc rdr_name) uniq
734 | Just name <- isExact_maybe rdr_name = name
735 -- This happens in code generated by Template Haskell
736 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
737 -- We only bind unqualified names here
738 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
739 mkInternalName uniq (rdrNameOcc rdr_name) loc
741 ---------------------
742 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
743 checkDupAndShadowedRdrNames doc loc_rdr_names
744 = do { checkDupRdrNames doc loc_rdr_names
746 ; checkShadowedNames doc envs
747 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
749 ---------------------
750 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
754 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
755 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
757 -- Make fresh Names and extend the environment
758 newLocalsRn rdr_names_w_loc `thenM` \names ->
759 bindLocalNames names (enclosed_scope names)
761 bindLocalNames :: [Name] -> RnM a -> RnM a
762 bindLocalNames names enclosed_scope
763 = getLocalRdrEnv `thenM` \ name_env ->
764 setLocalRdrEnv (extendLocalRdrEnv name_env names)
767 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
768 bindLocalNamesFV names enclosed_scope
769 = do { (result, fvs) <- bindLocalNames names enclosed_scope
770 ; returnM (result, delListFromNameSet fvs names) }
773 -------------------------------------
774 -- binLocalsFVRn is the same as bindLocalsRn
775 -- except that it deals with free vars
776 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
777 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
778 bindLocatedLocalsFV doc rdr_names enclosed_scope
779 = bindLocatedLocalsRn doc rdr_names $ \ names ->
780 enclosed_scope names `thenM` \ (thing, fvs) ->
781 returnM (thing, delListFromNameSet fvs names)
783 -------------------------------------
784 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
785 -> ([LHsTyVarBndr Name] -> RnM a)
787 -- Haskell-98 binding of type variables; e.g. within a data type decl
788 bindTyVarsRn doc_str tyvar_names enclosed_scope
790 located_tyvars = hsLTyVarLocNames tyvar_names
792 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
793 enclosed_scope (zipWith replace tyvar_names names)
795 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
797 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
798 -- Find the type variables in the pattern type
799 -- signatures that must be brought into scope
800 bindPatSigTyVars tys thing_inside
801 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
802 ; if not scoped_tyvars then
805 do { name_env <- getLocalRdrEnv
806 ; let locd_tvs = [ tv | ty <- tys
807 , tv <- extractHsTyRdrTyVars ty
808 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
809 nubbed_tvs = nubBy eqLocated locd_tvs
810 -- The 'nub' is important. For example:
811 -- f (x :: t) (y :: t) = ....
812 -- We don't want to complain about binding t twice!
814 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
816 doc_sig = text "In a pattern type-signature"
818 bindPatSigTyVarsFV :: [LHsType RdrName]
821 bindPatSigTyVarsFV tys thing_inside
822 = bindPatSigTyVars tys $ \ tvs ->
823 thing_inside `thenM` \ (result,fvs) ->
824 returnM (result, fvs `delListFromNameSet` tvs)
826 bindSigTyVarsFV :: [Name]
829 bindSigTyVarsFV tvs thing_inside
830 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
831 ; if not scoped_tyvars then
834 bindLocalNamesFV tvs thing_inside }
836 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
837 -- This function is used only in rnSourceDecl on InstDecl
838 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
840 -------------------------------------
841 checkDupRdrNames :: SDoc
844 checkDupRdrNames doc_str rdr_names_w_loc
845 = -- Check for duplicated names in a binding group
846 mappM_ (dupNamesErr getLoc doc_str) dups
848 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
850 checkDupNames :: SDoc
853 checkDupNames doc_str names
854 = -- Check for duplicated names in a binding group
855 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
857 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
859 -------------------------------------
860 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
861 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
862 = ifOptM Opt_WarnNameShadowing $
863 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
864 ; mappM_ check_shadow loc_rdr_names }
866 check_shadow (loc, occ)
867 | Just n <- mb_local = complain [ptext SLIT("bound at") <+> ppr loc]
868 | not (null gres) = complain (map pprNameProvenance gres)
869 | otherwise = return ()
871 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
872 mb_local = lookupLocalRdrOcc local_env occ
873 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
874 -- Make an Unqualified RdrName and look that up, so that
875 -- we don't find any GREs that are in scope qualified-only
879 %************************************************************************
881 \subsection{Free variable manipulation}
883 %************************************************************************
887 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
889 (ys, fvs_s) = unzip stuff
891 returnM (ys, plusFVs fvs_s)
893 -- because some of the rename functions are CPSed:
894 -- maps the function across the list from left to right;
895 -- collects all the free vars into one set
896 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
897 -> [a] -> ([b] -> RnM c) -> RnM c
899 mapFvRnCPS _ [] cont = cont []
900 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
901 mapFvRnCPS f xs $ \ xs' ->
906 %************************************************************************
908 \subsection{Envt utility functions}
910 %************************************************************************
913 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
914 warnUnusedModules mods
915 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
917 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
918 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
919 <+> text "is imported, but nothing from it is used,",
920 nest 2 (ptext SLIT("except perhaps instances visible in")
922 ptext SLIT("To suppress this warning, use:")
923 <+> ptext SLIT("import") <+> ppr m <> parens empty ]
926 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
927 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
928 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
930 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
931 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
932 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
934 check_unused :: DynFlag -> [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
935 check_unused flag names thing_inside
936 = do { (res, res_fvs) <- thing_inside
938 -- Warn about unused names
939 ; ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` res_fvs) names))
942 ; return (res, res_fvs) }
944 -------------------------
947 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
949 warnUnusedLocals names
950 = warnUnusedBinds [(n,LocalDef) | n<-names]
952 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
953 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
954 where reportable (name,_)
955 | isWiredInName name = False -- Don't report unused wired-in names
956 -- Otherwise we get a zillion warnings
958 | otherwise = reportIfUnused (nameOccName name)
960 -------------------------
962 warnUnusedName :: (Name, Provenance) -> RnM ()
963 warnUnusedName (name, LocalDef)
964 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
965 (ptext SLIT("Defined but not used"))
967 warnUnusedName (name, Imported is)
970 warn spec = addUnusedWarning name span msg
972 span = importSpecLoc spec
973 pp_mod = quotes (ppr (importSpecModule spec))
974 msg = ptext SLIT("Imported from") <+> pp_mod <+> ptext SLIT("but not used")
976 addUnusedWarning name span msg
979 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
980 <+> quotes (ppr name)]
984 addNameClashErrRn rdr_name names
985 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
986 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
989 msg1 = ptext SLIT("either") <+> mk_ref np1
990 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
991 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
993 shadowedNameWarn doc occ shadowed_locs
994 = sep [ptext SLIT("This binding for") <+> quotes (ppr occ)
995 <+> ptext SLIT("shadows the existing binding") <> plural shadowed_locs,
996 nest 2 (vcat shadowed_locs)]
999 unknownNameErr rdr_name
1000 = sep [ptext SLIT("Not in scope:"),
1001 nest 2 $ pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1002 <+> quotes (ppr rdr_name)]
1004 unknownSubordinateErr doc op -- Doc is "method of class" or
1005 -- "field of constructor"
1006 = quotes (ppr op) <+> ptext SLIT("is not a (visible)") <+> doc
1009 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1010 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1012 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1013 dupNamesErr get_loc descriptor names
1014 = addErrAt big_loc $
1015 vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr (head names)),
1016 locations, descriptor]
1018 locs = map get_loc names
1019 big_loc = foldr1 combineSrcSpans locs
1020 one_line = isOneLineSpan big_loc
1021 locations | one_line = empty
1022 | otherwise = ptext SLIT("Bound at:") <+>
1023 vcat (map ppr (sortLe (<=) locs))
1025 badQualBndrErr rdr_name
1026 = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name