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 checkDupNames, checkShadowing, mapFvRn, mapFvRnCPS,
35 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
36 warnUnusedTopBinds, warnUnusedLocalBinds,
37 dataTcOccs, unknownNameErr,
40 #include "HsVersions.h"
42 import LoadIface ( loadInterfaceForName, loadSrcInterface )
43 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
44 import HsSyn ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
45 LHsTyVarBndr, LHsType,
46 Fixity, hsLTyVarLocNames, replaceTyVarName )
47 import RdrHsSyn ( extractHsTyRdrTyVars )
48 import RdrName ( RdrName, isQual, isUnqual, isOrig_maybe,
50 mkRdrUnqual, setRdrNameSpace, rdrNameOcc,
51 pprGlobalRdrEnv, lookupGRE_RdrName,
52 isExact_maybe, isSrcRdrName,
54 GlobalRdrElt(..), GlobalRdrEnv, lookupGlobalRdrEnv,
55 isLocalGRE, extendLocalRdrEnv, elemLocalRdrEnv, lookupLocalRdrEnv,
56 Provenance(..), pprNameProvenance,
57 importSpecLoc, importSpecModule
59 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity)
60 import TcEnv ( tcLookupDataCon )
62 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
63 nameSrcLoc, nameOccName, nameModule, isExternalName )
67 import DataCon ( dataConFieldLabels )
68 import OccName ( tcName, isDataOcc, pprNonVarNameSpace, occNameSpace,
69 reportIfUnused, occNameFS )
70 import Module ( Module, ModuleName )
71 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE, consDataConKey, hasKey )
73 import BasicTypes ( IPName, mapIPName, Fixity )
74 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
75 srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
77 import Util ( sortLe )
79 import ListSetOps ( removeDups )
86 %*********************************************************
90 %*********************************************************
93 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
94 newTopSrcBinder this_mod (L loc rdr_name)
95 | Just name <- isExact_maybe rdr_name
96 = -- This is here to catch
97 -- (a) Exact-name binders created by Template Haskell
98 -- (b) The PrelBase defn of (say) [] and similar, for which
99 -- the parser reads the special syntax and returns an Exact RdrName
100 -- We are at a binding site for the name, so check first that it
101 -- the current module is the correct one; otherwise GHC can get
102 -- very confused indeed. This test rejects code like
103 -- data T = (,) Int Int
104 -- unless we are in GHC.Tup
105 ASSERT2( isExternalName name, ppr name )
106 do { checkM (this_mod == nameModule name)
107 (addErrAt loc (badOrigBinding rdr_name))
111 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
112 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
113 (addErrAt loc (badOrigBinding rdr_name))
114 -- When reading External Core we get Orig names as binders,
115 -- but they should agree with the module gotten from the monad
117 -- We can get built-in syntax showing up here too, sadly. If you type
119 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
120 -- uses setRdrNameSpace to make it into a data constructors. At that point
121 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
122 -- Hence the badOrigBinding error message.
124 -- Except for the ":Main.main = ..." definition inserted into
125 -- the Main module; ugh!
127 -- Because of this latter case, we call newGlobalBinder with a module from
128 -- the RdrName, not from the environment. In principle, it'd be fine to
129 -- have an arbitrary mixture of external core definitions in a single module,
130 -- (apart from module-initialisation issues, perhaps).
131 ; newGlobalBinder rdr_mod rdr_occ loc }
132 --TODO, should pass the whole span
135 = do { checkM (not (isQual rdr_name))
136 (addErrAt loc (badQualBndrErr rdr_name))
137 -- Binders should not be qualified; if they are, and with a different
138 -- module name, we we get a confusing "M.T is not in scope" error later
139 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
142 %*********************************************************
144 Source code occurrences
146 %*********************************************************
148 Looking up a name in the RnEnv.
151 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
152 lookupLocatedBndrRn = wrapLocM lookupBndrRn
154 lookupBndrRn :: RdrName -> RnM Name
155 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
158 Nothing -> do traceRn $ text "lookupTopBndrRn"
161 lookupTopBndrRn :: RdrName -> RnM Name
162 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
165 Nothing -> do traceRn $ text "lookupTopBndrRn"
168 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
169 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
170 lookupBndrRn_maybe rdr_name
171 = getLocalRdrEnv `thenM` \ local_env ->
172 case lookupLocalRdrEnv local_env rdr_name of
173 Just name -> returnM (Just name)
174 Nothing -> lookupTopBndrRn_maybe rdr_name
176 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
177 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
179 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
180 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
181 -- and there may be several imported 'f's too, which must not confuse us.
182 -- For example, this is OK:
184 -- infix 9 f -- The 'f' here does not need to be qualified
185 -- f x = x -- Nor here, of course
186 -- So we have to filter out the non-local ones.
188 -- A separate function (importsFromLocalDecls) reports duplicate top level
189 -- decls, so here it's safe just to choose an arbitrary one.
191 -- There should never be a qualified name in a binding position in Haskell,
192 -- but there can be if we have read in an external-Core file.
193 -- The Haskell parser checks for the illegal qualified name in Haskell
194 -- source files, so we don't need to do so here.
196 lookupTopBndrRn_maybe rdr_name
197 | Just name <- isExact_maybe rdr_name
198 = returnM (Just name)
200 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
201 -- This deals with the case of derived bindings, where
202 -- we don't bother to call newTopSrcBinder first
203 -- We assume there is no "parent" name
204 = do { loc <- getSrcSpanM
205 ; n <- newGlobalBinder rdr_mod rdr_occ loc
209 = do { mb_gre <- lookupGreLocalRn rdr_name
211 Nothing -> returnM Nothing
212 Just gre -> returnM (Just $ gre_name gre) }
214 -- lookupLocatedSigOccRn is used for type signatures and pragmas
220 -- It's clear that the 'f' in the signature must refer to A.f
221 -- The Haskell98 report does not stipulate this, but it will!
222 -- So we must treat the 'f' in the signature in the same way
223 -- as the binding occurrence of 'f', using lookupBndrRn
225 -- However, consider this case:
229 -- We don't want to say 'f' is out of scope; instead, we want to
230 -- return the imported 'f', so that later on the reanamer will
231 -- correctly report "misplaced type sig".
232 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
233 lookupLocatedSigOccRn = wrapLocM $ \ rdr_name -> do
234 { local_env <- getLocalRdrEnv
235 ; case lookupLocalRdrEnv local_env rdr_name of {
238 { mb_gre <- lookupGreLocalRn rdr_name
240 Just gre -> return (gre_name gre)
241 Nothing -> lookupGlobalOccRn rdr_name
244 -----------------------------------------------
245 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
246 -- This is called on the method name on the left-hand side of an
247 -- instance declaration binding. eg. instance Functor T where
249 -- ^^^^ called on this
250 -- Regardless of how many unqualified fmaps are in scope, we want
251 -- the one that comes from the Functor class.
253 -- Furthermore, note that we take no account of whether the
254 -- name is only in scope qualified. I.e. even if method op is
255 -- in scope as M.op, we still allow plain 'op' on the LHS of
257 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
259 doc = ptext SLIT("method of class") <+> quotes (ppr cls)
260 is_op gre@(GRE {gre_par = ParentIs n}) = n == cls
263 -----------------------------------------------
264 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
265 -- Used for record construction and pattern matching
266 -- When the -fdisambiguate-record-fields flag is on, take account of the
267 -- constructor name to disambiguate which field to use; it's just the
268 -- same as for instance decls
269 lookupRecordBndr Nothing rdr_name
270 = lookupLocatedGlobalOccRn rdr_name
271 lookupRecordBndr (Just (L _ data_con)) rdr_name
272 = do { flag_on <- doptM Opt_DisambiguateRecordFields
274 then lookupLocatedGlobalOccRn rdr_name
276 fields <- lookupConstructorFields data_con
277 ; let is_field gre = gre_name gre `elem` fields
278 ; lookup_located_sub_bndr is_field doc rdr_name
281 doc = ptext SLIT("field of constructor") <+> quotes (ppr data_con)
284 lookupConstructorFields :: Name -> RnM [Name]
285 -- Look up the fields of a given constructor
286 -- * For constructors from this module, use the record field env,
287 -- which is itself gathered from the (as yet un-typechecked)
290 -- * For constructors from imported modules, use the *type* environment
291 -- since imported modles are already compiled, the info is conveniently
294 lookupConstructorFields con_name
295 = do { this_mod <- getModule
296 ; if nameIsLocalOrFrom this_mod con_name then
297 do { field_env <- getRecFieldEnv
298 ; return (lookupNameEnv field_env con_name `orElse` []) }
300 do { con <- tcLookupDataCon con_name
301 ; return (dataConFieldLabels con) } }
303 -----------------------------------------------
304 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
305 -> SDoc -> Located RdrName
306 -> RnM (Located Name)
307 lookup_located_sub_bndr is_good doc rdr_name
308 = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
310 lookup_sub_bndr is_good doc rdr_name
311 | isUnqual rdr_name -- Find all the things the rdr-name maps to
312 = do { -- and pick the one with the right parent name
313 ; env <- getGlobalRdrEnv
314 ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
315 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
316 -- The latter does pickGREs, but we want to allow 'x'
317 -- even if only 'M.x' is in scope
318 [gre] -> return (gre_name gre)
319 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
320 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
321 ; return (mkUnboundName rdr_name) }
322 gres -> do { addNameClashErrRn rdr_name gres
323 ; return (gre_name (head gres)) }
326 | otherwise -- Occurs in derived instances, where we just
327 -- refer directly to the right method
328 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
329 -- NB: qualified names are rejected by the parser
330 lookupImportedName rdr_name
332 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
333 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
335 -- Looking up family names in type instances is a subtle affair. The family
336 -- may be imported, in which case we need to lookup the occurence of a global
337 -- name. Alternatively, the family may be in the same binding group (and in
338 -- fact in a declaration processed later), and we need to create a new top
341 -- So, also this is strictly speaking an occurence, we cannot raise an error
342 -- message yet for instances without a family declaration. This will happen
343 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
345 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
346 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
347 = do { mb_gre <- lookupGreRn_maybe rdr_name
349 Just gre -> returnM (gre_name gre) ;
350 Nothing -> newTopSrcBinder mod lrdr_name }
352 --------------------------------------------------
354 --------------------------------------------------
356 getLookupOccRn :: RnM (Name -> Maybe Name)
358 = getLocalRdrEnv `thenM` \ local_env ->
359 return (lookupLocalRdrEnv local_env . mkRdrUnqual . nameOccName)
361 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
362 lookupLocatedOccRn = wrapLocM lookupOccRn
364 -- lookupOccRn looks up an occurrence of a RdrName
365 lookupOccRn :: RdrName -> RnM Name
367 = getLocalRdrEnv `thenM` \ local_env ->
368 case lookupLocalRdrEnv local_env rdr_name of
369 Just name -> returnM name
370 Nothing -> lookupGlobalOccRn rdr_name
372 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
373 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
375 lookupGlobalOccRn :: RdrName -> RnM Name
376 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
377 -- environment. It's used only for
378 -- record field names
379 -- class op names in class and instance decls
381 lookupGlobalOccRn rdr_name
382 | not (isSrcRdrName rdr_name)
383 = lookupImportedName rdr_name
386 = -- First look up the name in the normal environment.
387 lookupGreRn_maybe rdr_name `thenM` \ mb_gre ->
389 Just gre -> returnM (gre_name gre) ;
392 -- We allow qualified names on the command line to refer to
393 -- *any* name exported by any module in scope, just as if
394 -- there was an "import qualified M" declaration for every
396 getModule `thenM` \ mod ->
397 if isQual rdr_name && mod == iNTERACTIVE then
398 -- This test is not expensive,
399 lookupQualifiedName rdr_name -- and only happens for failed lookups
401 traceRn $ text "lookupGlobalOccRn"
402 unboundName rdr_name }
404 lookupImportedName :: RdrName -> TcRnIf m n Name
405 -- Lookup the occurrence of an imported name
406 -- The RdrName is *always* qualified or Exact
407 -- Treat it as an original name, and conjure up the Name
408 -- Usually it's Exact or Orig, but it can be Qual if it
409 -- comes from an hi-boot file. (This minor infelicity is
410 -- just to reduce duplication in the parser.)
411 lookupImportedName rdr_name
412 | Just n <- isExact_maybe rdr_name
413 -- This happens in derived code
416 -- Always Orig, even when reading a .hi-boot file
417 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
418 = lookupOrig rdr_mod rdr_occ
421 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
423 unboundName :: RdrName -> RnM Name
425 = do { addErr (unknownNameErr rdr_name)
426 ; env <- getGlobalRdrEnv;
427 ; traceRn (vcat [unknownNameErr rdr_name,
428 ptext SLIT("Global envt is:"),
429 nest 3 (pprGlobalRdrEnv env)])
430 ; returnM (mkUnboundName rdr_name) }
432 --------------------------------------------------
433 -- Lookup in the Global RdrEnv of the module
434 --------------------------------------------------
436 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
437 -- No filter function; does not report an error on failure
438 lookupSrcOcc_maybe rdr_name
439 = do { mb_gre <- lookupGreRn_maybe rdr_name
441 Nothing -> returnM Nothing
442 Just gre -> returnM (Just (gre_name gre)) }
444 -------------------------
445 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
446 -- Just look up the RdrName in the GlobalRdrEnv
447 lookupGreRn_maybe rdr_name
448 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
450 lookupGreRn :: RdrName -> RnM GlobalRdrElt
451 -- If not found, add error message, and return a fake GRE
453 = do { mb_gre <- lookupGreRn_maybe rdr_name
455 Just gre -> return gre ;
457 { traceRn $ text "lookupGreRn"
458 ; name <- unboundName rdr_name
459 ; return (GRE { gre_name = name, gre_par = NoParent,
460 gre_prov = LocalDef }) }}}
462 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
463 -- Similar, but restricted to locally-defined things
464 lookupGreLocalRn rdr_name
465 = lookupGreRn_help rdr_name lookup_fn
467 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
469 lookupGreRn_help :: RdrName -- Only used in error message
470 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
471 -> RnM (Maybe GlobalRdrElt)
472 -- Checks for exactly one match; reports deprecations
473 -- Returns Nothing, without error, if too few
474 lookupGreRn_help rdr_name lookup
475 = do { env <- getGlobalRdrEnv
477 [] -> returnM Nothing
478 [gre] -> returnM (Just gre)
479 gres -> do { addNameClashErrRn rdr_name gres
480 ; returnM (Just (head gres)) } }
482 ------------------------------
484 ------------------------------
486 -- A qualified name on the command line can refer to any module at all: we
487 -- try to load the interface if we don't already have it.
488 lookupQualifiedName :: RdrName -> RnM Name
489 lookupQualifiedName rdr_name
490 | Just (mod,occ) <- isQual_maybe rdr_name
491 -- Note: we want to behave as we would for a source file import here,
492 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
493 = loadSrcInterface doc mod False `thenM` \ iface ->
496 (mod,avails) <- mi_exports iface,
498 name <- availNames avail,
500 ((mod,occ):ns) -> ASSERT (null ns)
502 _ -> unboundName rdr_name
505 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
507 doc = ptext SLIT("Need to find") <+> ppr rdr_name
510 %*********************************************************
514 %*********************************************************
517 lookupLocalDataTcNames :: RdrName -> RnM [Name]
518 -- GHC extension: look up both the tycon and data con
519 -- for con-like things
520 -- Complain if neither is in scope
521 lookupLocalDataTcNames rdr_name
522 | Just n <- isExact_maybe rdr_name
523 -- Special case for (:), which doesn't get into the GlobalRdrEnv
524 = return [n] -- For this we don't need to try the tycon too
526 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
527 ; case [gre_name gre | Just gre <- mb_gres] of
529 -- run for error reporting
530 ; unboundName rdr_name
532 names -> return names
535 --------------------------------
536 bindLocalFixities :: [FixitySig RdrName] -> (UniqFM (Located Fixity) -> RnM a) -> RnM a
537 -- Used for nested fixity decls:
538 -- bind the names that are in scope already;
539 -- pass the rest to the continuation for later
540 -- as a FastString->(Located Fixity) map
542 -- No need to worry about type constructors here,
543 -- Should check for duplicates?
544 bindLocalFixities fixes thing_inside
545 | null fixes = thing_inside emptyUFM
546 | otherwise = do ls <- mappM rn_sig fixes
547 let (now, later) = nowAndLater ls
548 extendFixityEnv now $ thing_inside later
550 rn_sig (FixitySig lv@(L loc v) fix) = do
551 vopt <- lookupBndrRn_maybe v
553 Just new_v -> returnM (Left (new_v, (FixItem (rdrNameOcc v) fix)))
554 Nothing -> returnM (Right (occNameFS $ rdrNameOcc v, (L loc fix)))
556 nowAndLater (ls :: [Either (Name, FixItem) (FastString, Located Fixity)]) =
557 foldr (\ cur -> \ (now, later) ->
559 Left (n, f) -> ((n, f) : now, later)
560 Right (fs, f) -> (now, addToUFM later fs f))
563 -- Used for nested fixity decls to bind names along with their fixities.
564 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
565 bindLocalNamesFV_WithFixities :: [Name] -> UniqFM (Located Fixity) -> RnM (a, FreeVars) -> RnM (a, FreeVars)
566 bindLocalNamesFV_WithFixities names fixities cont =
567 -- find the names that have fixity decls
568 let boundFixities = foldr
570 -- check whether this name has a fixity decl
571 case lookupUFM fixities (occNameFS (nameOccName name)) of
572 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
573 Nothing -> acc) [] names in
574 -- bind the names; extend the fixity env; do the thing inside
575 bindLocalNamesFV names (extendFixityEnv boundFixities cont)
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 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
745 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
746 = -- Check for duplicate names
747 checkDupNames doc_str rdr_names_w_loc `thenM_`
749 -- Warn about shadowing, but only in source modules
750 ifOptM Opt_WarnNameShadowing
751 (checkShadowing doc_str rdr_names_w_loc) `thenM_`
753 -- Make fresh Names and extend the environment
754 newLocalsRn rdr_names_w_loc `thenM` \ names ->
755 getLocalRdrEnv `thenM` \ local_env ->
756 setLocalRdrEnv (extendLocalRdrEnv local_env names)
757 (enclosed_scope names)
759 bindLocalNames :: [Name] -> RnM a -> RnM a
760 bindLocalNames names enclosed_scope
761 = getLocalRdrEnv `thenM` \ name_env ->
762 setLocalRdrEnv (extendLocalRdrEnv name_env names)
765 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
766 bindLocalNamesFV names enclosed_scope
767 = do { (result, fvs) <- bindLocalNames names enclosed_scope
768 ; returnM (result, delListFromNameSet fvs names) }
771 -------------------------------------
772 -- binLocalsFVRn is the same as bindLocalsRn
773 -- except that it deals with free vars
774 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
775 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
776 bindLocatedLocalsFV doc rdr_names enclosed_scope
777 = bindLocatedLocalsRn doc rdr_names $ \ names ->
778 enclosed_scope names `thenM` \ (thing, fvs) ->
779 returnM (thing, delListFromNameSet fvs names)
781 -------------------------------------
782 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
783 -> ([LHsTyVarBndr Name] -> RnM a)
785 -- Haskell-98 binding of type variables; e.g. within a data type decl
786 bindTyVarsRn doc_str tyvar_names enclosed_scope
788 located_tyvars = hsLTyVarLocNames tyvar_names
790 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
791 enclosed_scope (zipWith replace tyvar_names names)
793 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
795 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
796 -- Find the type variables in the pattern type
797 -- signatures that must be brought into scope
798 bindPatSigTyVars tys thing_inside
799 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
800 ; if not scoped_tyvars then
803 do { name_env <- getLocalRdrEnv
804 ; let locd_tvs = [ tv | ty <- tys
805 , tv <- extractHsTyRdrTyVars ty
806 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
807 nubbed_tvs = nubBy eqLocated locd_tvs
808 -- The 'nub' is important. For example:
809 -- f (x :: t) (y :: t) = ....
810 -- We don't want to complain about binding t twice!
812 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
814 doc_sig = text "In a pattern type-signature"
816 bindPatSigTyVarsFV :: [LHsType RdrName]
819 bindPatSigTyVarsFV tys thing_inside
820 = bindPatSigTyVars tys $ \ tvs ->
821 thing_inside `thenM` \ (result,fvs) ->
822 returnM (result, fvs `delListFromNameSet` tvs)
824 bindSigTyVarsFV :: [Name]
827 bindSigTyVarsFV tvs thing_inside
828 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
829 ; if not scoped_tyvars then
832 bindLocalNamesFV tvs thing_inside }
834 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
835 -- This function is used only in rnSourceDecl on InstDecl
836 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
838 -------------------------------------
839 checkDupNames :: SDoc
842 checkDupNames doc_str rdr_names_w_loc
843 = -- Check for duplicated names in a binding group
844 mappM_ (dupNamesErr doc_str) dups
846 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
848 -------------------------------------
849 checkShadowing doc_str loc_rdr_names
850 = getLocalRdrEnv `thenM` \ local_env ->
851 getGlobalRdrEnv `thenM` \ global_env ->
853 check_shadow (L loc rdr_name)
854 | rdr_name `elemLocalRdrEnv` local_env
855 || not (null (lookupGRE_RdrName rdr_name global_env ))
856 = addWarnAt loc (shadowedNameWarn doc_str rdr_name)
857 | otherwise = returnM ()
859 mappM_ check_shadow loc_rdr_names
863 %************************************************************************
865 \subsection{Free variable manipulation}
867 %************************************************************************
871 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
873 (ys, fvs_s) = unzip stuff
875 returnM (ys, plusFVs fvs_s)
877 -- because some of the rename functions are CPSed:
878 -- maps the function across the list from left to right;
879 -- collects all the free vars into one set
880 mapFvRnCPS :: (a -> ((b,FreeVars) -> RnM (c, FreeVars)) -> RnM(c, FreeVars))
882 -> (([b],FreeVars) -> RnM (c, FreeVars))
885 mapFvRnCPS _ [] cont = cont ([], emptyFVs)
887 mapFvRnCPS f (h:t) cont = f h $ \ (h',hfv) ->
888 mapFvRnCPS f t $ \ (t',tfv) ->
889 cont (h':t', hfv `plusFV` tfv)
893 %************************************************************************
895 \subsection{Envt utility functions}
897 %************************************************************************
900 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
901 warnUnusedModules mods
902 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
904 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
905 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
906 <+> text "is imported, but nothing from it is used,",
907 nest 2 (ptext SLIT("except perhaps instances visible in")
909 ptext SLIT("To suppress this warning, use:")
910 <+> ptext SLIT("import") <+> ppr m <> parens empty ]
913 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
914 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
915 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
917 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM ()
918 warnUnusedLocalBinds names = ifOptM Opt_WarnUnusedBinds (warnUnusedLocals names)
919 warnUnusedMatches names = ifOptM Opt_WarnUnusedMatches (warnUnusedLocals names)
921 -------------------------
924 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
926 warnUnusedLocals names
927 = warnUnusedBinds [(n,LocalDef) | n<-names]
929 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
930 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
931 where reportable (name,_)
932 | isWiredInName name = False -- Don't report unused wired-in names
933 -- Otherwise we get a zillion warnings
935 | otherwise = reportIfUnused (nameOccName name)
937 -------------------------
939 warnUnusedName :: (Name, Provenance) -> RnM ()
940 warnUnusedName (name, LocalDef)
941 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
942 (ptext SLIT("Defined but not used"))
944 warnUnusedName (name, Imported is)
947 warn spec = addUnusedWarning name span msg
949 span = importSpecLoc spec
950 pp_mod = quotes (ppr (importSpecModule spec))
951 msg = ptext SLIT("Imported from") <+> pp_mod <+> ptext SLIT("but not used")
953 addUnusedWarning name span msg
956 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
957 <+> quotes (ppr name)]
961 addNameClashErrRn rdr_name names
962 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
963 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
966 msg1 = ptext SLIT("either") <+> mk_ref np1
967 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
968 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
970 shadowedNameWarn doc shadow
971 = hsep [ptext SLIT("This binding for"),
973 ptext SLIT("shadows an existing binding")]
976 unknownNameErr rdr_name
977 = sep [ptext SLIT("Not in scope:"),
978 nest 2 $ pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
979 <+> quotes (ppr rdr_name)]
981 unknownSubordinateErr doc op -- Doc is "method of class" or
982 -- "field of constructor"
983 = quotes (ppr op) <+> ptext SLIT("is not a (visible)") <+> doc
986 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
987 -- The rdrNameOcc is because we don't want to print Prelude.(,)
989 dupNamesErr :: SDoc -> [Located RdrName] -> RnM ()
990 dupNamesErr descriptor located_names
992 vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr name1),
993 locations, descriptor]
995 L _ name1 = head located_names
996 locs = map getLoc located_names
997 big_loc = foldr1 combineSrcSpans locs
998 one_line = isOneLineSpan big_loc
999 locations | one_line = empty
1000 | otherwise = ptext SLIT("Bound at:") <+>
1001 vcat (map ppr (sortLe (<=) locs))
1003 badQualBndrErr rdr_name
1004 = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name