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,
29 MiniFixityEnv, bindLocalNamesFV_WithFixities,
30 bindLocatedLocalsFV, bindLocatedLocalsRn,
31 bindSigTyVarsFV, bindPatSigTyVars, bindPatSigTyVarsFV,
32 bindTyVarsRn, extendTyVarEnvFVRn,
35 checkDupRdrNames, checkDupNames, checkShadowedNames,
36 checkDupAndShadowedRdrNames,
38 warnUnusedMatches, warnUnusedModules, warnUnusedImports,
39 warnUnusedTopBinds, warnUnusedLocalBinds,
40 dataTcOccs, unknownNameErr
43 #include "HsVersions.h"
45 import LoadIface ( loadInterfaceForName, loadSrcInterface )
46 import IfaceEnv ( lookupOrig, newGlobalBinder, newIPName )
47 import HsSyn ( FixitySig(..), HsExpr(..), SyntaxExpr, SyntaxTable,
48 LHsTyVarBndr, LHsType,
49 Fixity, hsLTyVarLocNames, replaceTyVarName )
50 import RdrHsSyn ( extractHsTyRdrTyVars )
52 import HscTypes ( availNames, ModIface(..), FixItem(..), lookupFixity)
53 import TcEnv ( tcLookupDataCon )
55 import Name ( Name, nameIsLocalOrFrom, mkInternalName, isWiredInName,
56 nameSrcLoc, nameSrcSpan, nameOccName, nameModule, isExternalName )
60 import DataCon ( dataConFieldLabels )
62 import Module ( Module, ModuleName )
63 import PrelNames ( mkUnboundName, rOOT_MAIN, iNTERACTIVE,
64 consDataConKey, hasKey, forall_tv_RDR )
66 import BasicTypes ( IPName, mapIPName, Fixity )
67 import SrcLoc ( SrcSpan, srcSpanStart, Located(..), eqLocated, unLoc,
68 srcLocSpan, getLoc, combineSrcSpans, isOneLineSpan )
72 import ListSetOps ( removeDups )
81 thenM :: Monad a => a b -> (b -> a c) -> a c
84 thenM_ :: Monad a => a b -> a c -> a c
87 returnM :: Monad m => a -> m a
90 mappM :: (Monad m) => (a -> m b) -> [a] -> m [b]
93 mappM_ :: (Monad m) => (a -> m b) -> [a] -> m ()
96 checkM :: Monad m => Bool -> m () -> m ()
100 %*********************************************************
104 %*********************************************************
107 newTopSrcBinder :: Module -> Located RdrName -> RnM Name
108 newTopSrcBinder this_mod (L loc rdr_name)
109 | Just name <- isExact_maybe rdr_name
110 = -- This is here to catch
111 -- (a) Exact-name binders created by Template Haskell
112 -- (b) The PrelBase defn of (say) [] and similar, for which
113 -- the parser reads the special syntax and returns an Exact RdrName
114 -- We are at a binding site for the name, so check first that it
115 -- the current module is the correct one; otherwise GHC can get
116 -- very confused indeed. This test rejects code like
117 -- data T = (,) Int Int
118 -- unless we are in GHC.Tup
119 ASSERT2( isExternalName name, ppr name )
120 do { checkM (this_mod == nameModule name)
121 (addErrAt loc (badOrigBinding rdr_name))
125 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
126 = do { checkM (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
127 (addErrAt loc (badOrigBinding rdr_name))
128 -- When reading External Core we get Orig names as binders,
129 -- but they should agree with the module gotten from the monad
131 -- We can get built-in syntax showing up here too, sadly. If you type
133 -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
134 -- uses setRdrNameSpace to make it into a data constructors. At that point
135 -- the nice Exact name for the TyCon gets swizzled to an Orig name.
136 -- Hence the badOrigBinding error message.
138 -- Except for the ":Main.main = ..." definition inserted into
139 -- the Main module; ugh!
141 -- Because of this latter case, we call newGlobalBinder with a module from
142 -- the RdrName, not from the environment. In principle, it'd be fine to
143 -- have an arbitrary mixture of external core definitions in a single module,
144 -- (apart from module-initialisation issues, perhaps).
145 ; newGlobalBinder rdr_mod rdr_occ loc }
146 --TODO, should pass the whole span
149 = do { checkM (not (isQual rdr_name))
150 (addErrAt loc (badQualBndrErr rdr_name))
151 -- Binders should not be qualified; if they are, and with a different
152 -- module name, we we get a confusing "M.T is not in scope" error later
153 ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc }
156 %*********************************************************
158 Source code occurrences
160 %*********************************************************
162 Looking up a name in the RnEnv.
165 lookupLocatedBndrRn :: Located RdrName -> RnM (Located Name)
166 lookupLocatedBndrRn = wrapLocM lookupBndrRn
168 lookupBndrRn :: RdrName -> RnM Name
169 lookupBndrRn n = do nopt <- lookupBndrRn_maybe n
172 Nothing -> do traceRn $ text "lookupTopBndrRn"
175 lookupTopBndrRn :: RdrName -> RnM Name
176 lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
179 Nothing -> do traceRn $ text "lookupTopBndrRn"
182 lookupBndrRn_maybe :: RdrName -> RnM (Maybe Name)
183 -- NOTE: assumes that the SrcSpan of the binder has already been setSrcSpan'd
184 lookupBndrRn_maybe rdr_name
185 = getLocalRdrEnv `thenM` \ local_env ->
186 case lookupLocalRdrEnv local_env rdr_name of
187 Just name -> returnM (Just name)
188 Nothing -> lookupTopBndrRn_maybe rdr_name
190 lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
191 lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn
193 lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
194 -- Look up a top-level source-code binder. We may be looking up an unqualified 'f',
195 -- and there may be several imported 'f's too, which must not confuse us.
196 -- For example, this is OK:
198 -- infix 9 f -- The 'f' here does not need to be qualified
199 -- f x = x -- Nor here, of course
200 -- So we have to filter out the non-local ones.
202 -- A separate function (importsFromLocalDecls) reports duplicate top level
203 -- decls, so here it's safe just to choose an arbitrary one.
205 -- There should never be a qualified name in a binding position in Haskell,
206 -- but there can be if we have read in an external-Core file.
207 -- The Haskell parser checks for the illegal qualified name in Haskell
208 -- source files, so we don't need to do so here.
210 lookupTopBndrRn_maybe rdr_name
211 | Just name <- isExact_maybe rdr_name
212 = returnM (Just name)
214 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
215 -- This deals with the case of derived bindings, where
216 -- we don't bother to call newTopSrcBinder first
217 -- We assume there is no "parent" name
218 = do { loc <- getSrcSpanM
219 ; n <- newGlobalBinder rdr_mod rdr_occ loc
223 = do { mb_gre <- lookupGreLocalRn rdr_name
225 Nothing -> returnM Nothing
226 Just gre -> returnM (Just $ gre_name gre) }
228 -- lookupLocatedSigOccRn is used for type signatures and pragmas
234 -- It's clear that the 'f' in the signature must refer to A.f
235 -- The Haskell98 report does not stipulate this, but it will!
236 -- So we must treat the 'f' in the signature in the same way
237 -- as the binding occurrence of 'f', using lookupBndrRn
239 -- However, consider this case:
243 -- We don't want to say 'f' is out of scope; instead, we want to
244 -- return the imported 'f', so that later on the reanamer will
245 -- correctly report "misplaced type sig".
246 lookupLocatedSigOccRn :: Located RdrName -> RnM (Located Name)
247 lookupLocatedSigOccRn = wrapLocM $ \ rdr_name -> do
248 { local_env <- getLocalRdrEnv
249 ; case lookupLocalRdrEnv local_env rdr_name of {
252 { mb_gre <- lookupGreLocalRn rdr_name
254 Just gre -> return (gre_name gre)
255 Nothing -> lookupGlobalOccRn rdr_name
258 -----------------------------------------------
259 lookupInstDeclBndr :: Name -> Located RdrName -> RnM (Located Name)
260 -- This is called on the method name on the left-hand side of an
261 -- instance declaration binding. eg. instance Functor T where
263 -- ^^^^ called on this
264 -- Regardless of how many unqualified fmaps are in scope, we want
265 -- the one that comes from the Functor class.
267 -- Furthermore, note that we take no account of whether the
268 -- name is only in scope qualified. I.e. even if method op is
269 -- in scope as M.op, we still allow plain 'op' on the LHS of
271 lookupInstDeclBndr cls rdr = lookup_located_sub_bndr is_op doc rdr
273 doc = ptext SLIT("method of class") <+> quotes (ppr cls)
274 is_op gre@(GRE {gre_par = ParentIs n}) = n == cls
277 -----------------------------------------------
278 lookupRecordBndr :: Maybe (Located Name) -> Located RdrName -> RnM (Located Name)
279 -- Used for record construction and pattern matching
280 -- When the -fdisambiguate-record-fields flag is on, take account of the
281 -- constructor name to disambiguate which field to use; it's just the
282 -- same as for instance decls
283 lookupRecordBndr Nothing rdr_name
284 = lookupLocatedGlobalOccRn rdr_name
285 lookupRecordBndr (Just (L _ data_con)) rdr_name
286 = do { flag_on <- doptM Opt_DisambiguateRecordFields
288 then lookupLocatedGlobalOccRn rdr_name
290 fields <- lookupConstructorFields data_con
291 ; let is_field gre = gre_name gre `elem` fields
292 ; lookup_located_sub_bndr is_field doc rdr_name
295 doc = ptext SLIT("field of constructor") <+> quotes (ppr data_con)
298 lookupConstructorFields :: Name -> RnM [Name]
299 -- Look up the fields of a given constructor
300 -- * For constructors from this module, use the record field env,
301 -- which is itself gathered from the (as yet un-typechecked)
304 -- * For constructors from imported modules, use the *type* environment
305 -- since imported modles are already compiled, the info is conveniently
308 lookupConstructorFields con_name
309 = do { this_mod <- getModule
310 ; if nameIsLocalOrFrom this_mod con_name then
311 do { field_env <- getRecFieldEnv
312 ; return (lookupNameEnv field_env con_name `orElse` []) }
314 do { con <- tcLookupDataCon con_name
315 ; return (dataConFieldLabels con) } }
317 -----------------------------------------------
318 lookup_located_sub_bndr :: (GlobalRdrElt -> Bool)
319 -> SDoc -> Located RdrName
320 -> RnM (Located Name)
321 lookup_located_sub_bndr is_good doc rdr_name
322 = wrapLocM (lookup_sub_bndr is_good doc) rdr_name
324 lookup_sub_bndr is_good doc rdr_name
325 | isUnqual rdr_name -- Find all the things the rdr-name maps to
326 = do { -- and pick the one with the right parent name
327 ; env <- getGlobalRdrEnv
328 ; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
329 -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
330 -- The latter does pickGREs, but we want to allow 'x'
331 -- even if only 'M.x' is in scope
332 [gre] -> return (gre_name gre)
333 [] -> do { addErr (unknownSubordinateErr doc rdr_name)
334 ; traceRn (text "RnEnv.lookup_sub_bndr" <+> ppr rdr_name)
335 ; return (mkUnboundName rdr_name) }
336 gres -> do { addNameClashErrRn rdr_name gres
337 ; return (gre_name (head gres)) }
340 | otherwise -- Occurs in derived instances, where we just
341 -- refer directly to the right method
342 = ASSERT2( not (isQual rdr_name), ppr rdr_name )
343 -- NB: qualified names are rejected by the parser
344 lookupImportedName rdr_name
346 newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
347 newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
349 -- Looking up family names in type instances is a subtle affair. The family
350 -- may be imported, in which case we need to lookup the occurence of a global
351 -- name. Alternatively, the family may be in the same binding group (and in
352 -- fact in a declaration processed later), and we need to create a new top
355 -- So, also this is strictly speaking an occurence, we cannot raise an error
356 -- message yet for instances without a family declaration. This will happen
357 -- during renaming the type instance declaration in RnSource.rnTyClDecl.
359 lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
360 lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
361 = do { mb_gre <- lookupGreRn_maybe rdr_name
363 Just gre -> returnM (gre_name gre) ;
364 Nothing -> newTopSrcBinder mod lrdr_name }
366 --------------------------------------------------
368 --------------------------------------------------
370 getLookupOccRn :: RnM (Name -> Maybe Name)
372 = getLocalRdrEnv `thenM` \ local_env ->
373 return (lookupLocalRdrOcc local_env . nameOccName)
375 lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
376 lookupLocatedOccRn = wrapLocM lookupOccRn
378 -- lookupOccRn looks up an occurrence of a RdrName
379 lookupOccRn :: RdrName -> RnM Name
381 = getLocalRdrEnv `thenM` \ local_env ->
382 case lookupLocalRdrEnv local_env rdr_name of
383 Just name -> returnM name
384 Nothing -> lookupGlobalOccRn rdr_name
386 lookupLocatedGlobalOccRn :: Located RdrName -> RnM (Located Name)
387 lookupLocatedGlobalOccRn = wrapLocM lookupGlobalOccRn
389 lookupGlobalOccRn :: RdrName -> RnM Name
390 -- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
391 -- environment. It's used only for
392 -- record field names
393 -- class op names in class and instance decls
395 lookupGlobalOccRn rdr_name
396 | not (isSrcRdrName rdr_name)
397 = lookupImportedName rdr_name
400 = -- First look up the name in the normal environment.
401 lookupGreRn_maybe rdr_name `thenM` \ mb_gre ->
403 Just gre -> returnM (gre_name gre) ;
406 -- We allow qualified names on the command line to refer to
407 -- *any* name exported by any module in scope, just as if
408 -- there was an "import qualified M" declaration for every
410 getModule `thenM` \ mod ->
411 if isQual rdr_name && mod == iNTERACTIVE then
412 -- This test is not expensive,
413 lookupQualifiedName rdr_name -- and only happens for failed lookups
415 traceRn $ text "lookupGlobalOccRn"
416 unboundName rdr_name }
418 lookupImportedName :: RdrName -> TcRnIf m n Name
419 -- Lookup the occurrence of an imported name
420 -- The RdrName is *always* qualified or Exact
421 -- Treat it as an original name, and conjure up the Name
422 -- Usually it's Exact or Orig, but it can be Qual if it
423 -- comes from an hi-boot file. (This minor infelicity is
424 -- just to reduce duplication in the parser.)
425 lookupImportedName rdr_name
426 | Just n <- isExact_maybe rdr_name
427 -- This happens in derived code
430 -- Always Orig, even when reading a .hi-boot file
431 | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
432 = lookupOrig rdr_mod rdr_occ
435 = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
437 unboundName :: RdrName -> RnM Name
439 = do { addErr (unknownNameErr rdr_name)
440 ; env <- getGlobalRdrEnv;
441 ; traceRn (vcat [unknownNameErr rdr_name,
442 ptext SLIT("Global envt is:"),
443 nest 3 (pprGlobalRdrEnv env)])
444 ; returnM (mkUnboundName rdr_name) }
446 --------------------------------------------------
447 -- Lookup in the Global RdrEnv of the module
448 --------------------------------------------------
450 lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
451 -- No filter function; does not report an error on failure
452 lookupSrcOcc_maybe rdr_name
453 = do { mb_gre <- lookupGreRn_maybe rdr_name
455 Nothing -> returnM Nothing
456 Just gre -> returnM (Just (gre_name gre)) }
458 -------------------------
459 lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
460 -- Just look up the RdrName in the GlobalRdrEnv
461 lookupGreRn_maybe rdr_name
462 = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
464 lookupGreRn :: RdrName -> RnM GlobalRdrElt
465 -- If not found, add error message, and return a fake GRE
467 = do { mb_gre <- lookupGreRn_maybe rdr_name
469 Just gre -> return gre ;
471 { traceRn $ text "lookupGreRn"
472 ; name <- unboundName rdr_name
473 ; return (GRE { gre_name = name, gre_par = NoParent,
474 gre_prov = LocalDef }) }}}
476 lookupGreLocalRn :: RdrName -> RnM (Maybe GlobalRdrElt)
477 -- Similar, but restricted to locally-defined things
478 lookupGreLocalRn rdr_name
479 = lookupGreRn_help rdr_name lookup_fn
481 lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)
483 lookupGreRn_help :: RdrName -- Only used in error message
484 -> (GlobalRdrEnv -> [GlobalRdrElt]) -- Lookup function
485 -> RnM (Maybe GlobalRdrElt)
486 -- Checks for exactly one match; reports deprecations
487 -- Returns Nothing, without error, if too few
488 lookupGreRn_help rdr_name lookup
489 = do { env <- getGlobalRdrEnv
491 [] -> returnM Nothing
492 [gre] -> returnM (Just gre)
493 gres -> do { addNameClashErrRn rdr_name gres
494 ; returnM (Just (head gres)) } }
496 ------------------------------
498 ------------------------------
500 -- A qualified name on the command line can refer to any module at all: we
501 -- try to load the interface if we don't already have it.
502 lookupQualifiedName :: RdrName -> RnM Name
503 lookupQualifiedName rdr_name
504 | Just (mod,occ) <- isQual_maybe rdr_name
505 -- Note: we want to behave as we would for a source file import here,
506 -- and respect hiddenness of modules/packages, hence loadSrcInterface.
507 = loadSrcInterface doc mod False `thenM` \ iface ->
510 (mod,avails) <- mi_exports iface,
512 name <- availNames avail,
514 ((mod,occ):ns) -> ASSERT (null ns)
516 _ -> unboundName rdr_name
519 = pprPanic "RnEnv.lookupQualifiedName" (ppr rdr_name)
521 doc = ptext SLIT("Need to find") <+> ppr rdr_name
524 %*********************************************************
528 %*********************************************************
531 lookupLocalDataTcNames :: RdrName -> RnM [Name]
532 -- GHC extension: look up both the tycon and data con
533 -- for con-like things
534 -- Complain if neither is in scope
535 lookupLocalDataTcNames rdr_name
536 | Just n <- isExact_maybe rdr_name
537 -- Special case for (:), which doesn't get into the GlobalRdrEnv
538 = return [n] -- For this we don't need to try the tycon too
540 = do { mb_gres <- mapM lookupGreLocalRn (dataTcOccs rdr_name)
541 ; case [gre_name gre | Just gre <- mb_gres] of
543 -- run for error reporting
544 ; unboundName rdr_name
546 names -> return names
549 --------------------------------
550 type MiniFixityEnv = OccEnv (Located Fixity)
551 -- Mini fixity env for the names we're about
552 -- to bind, in a single binding group
554 -- We keep the location so that if we find
555 -- a duplicate, we can report it sensibly
557 bindLocalFixities :: [FixitySig RdrName] -> (UniqFM (Located Fixity) -> RnM a) -> RnM a
558 -- Used for nested fixity decls:
559 -- bind the names that are in scope already;
560 -- pass the rest to the continuation for later
561 -- as a FastString->(Located Fixity) map
563 -- No need to worry about type constructors here,
564 -- Should check for duplicates?
565 bindLocalFixities fixes thing_inside
566 | null fixes = thing_inside emptyUFM
567 | otherwise = do ls <- mappM rn_sig fixes
568 let (now, later) = nowAndLater ls
569 extendFixityEnv now $ thing_inside later
571 rn_sig (FixitySig lv@(L loc v) fix) = do
572 vopt <- lookupBndrRn_maybe v
574 Just new_v -> returnM (Left (new_v, (FixItem (rdrNameOcc v) fix)))
575 Nothing -> returnM (Right (occNameFS $ rdrNameOcc v, (L loc fix)))
577 nowAndLater :: [Either (Name, FixItem) (FastString, Located Fixity)]
578 -> ([(Name,FixItem)], UniqFM (Located Fixity))
580 foldr (\ cur -> \ (now, later) ->
582 Left (n, f) -> ((n, f) : now, later)
583 Right (fs, f) -> (now, addToUFM later fs f))
586 -- Used for nested fixity decls to bind names along with their fixities.
587 -- the fixities are given as a UFM from an OccName's FastString to a fixity decl
588 -- Also check for unused binders
589 bindLocalNamesFV_WithFixities :: [Name]
591 -> RnM (a, FreeVars) -> RnM (a, FreeVars)
592 bindLocalNamesFV_WithFixities names fixities thing_inside
593 = bindLocalNamesFV names $
594 extendFixityEnv boundFixities $
597 -- find the names that have fixity decls
598 boundFixities = foldr
600 -- check whether this name has a fixity decl
601 case lookupOccEnv fixities (nameOccName name) of
602 Just (L _ fix) -> (name, FixItem (nameOccName name) fix) : acc
603 Nothing -> acc) [] names
604 -- bind the names; extend the fixity env; do the thing inside
607 --------------------------------
608 lookupFixity is a bit strange.
610 * Nested local fixity decls are put in the local fixity env, which we
611 find with getFixtyEnv
613 * Imported fixities are found in the HIT or PIT
615 * Top-level fixity decls in this module may be for Names that are
616 either Global (constructors, class operations)
617 or Local/Exported (everything else)
618 (See notes with RnNames.getLocalDeclBinders for why we have this split.)
619 We put them all in the local fixity environment
622 lookupFixityRn :: Name -> RnM Fixity
624 = getModule `thenM` \ this_mod ->
625 if nameIsLocalOrFrom this_mod name
626 then do -- It's defined in this module
627 local_fix_env <- getFixityEnv
628 traceRn (text "lookupFixityRn: looking up name in local environment:" <+>
629 vcat [ppr name, ppr local_fix_env])
630 return $ lookupFixity local_fix_env name
631 else -- It's imported
632 -- For imported names, we have to get their fixities by doing a
633 -- loadInterfaceForName, and consulting the Ifaces that comes back
634 -- from that, because the interface file for the Name might not
635 -- have been loaded yet. Why not? Suppose you import module A,
636 -- which exports a function 'f', thus;
637 -- module CurrentModule where
639 -- module A( f ) where
641 -- Then B isn't loaded right away (after all, it's possible that
642 -- nothing from B will be used). When we come across a use of
643 -- 'f', we need to know its fixity, and it's then, and only
644 -- then, that we load B.hi. That is what's happening here.
646 -- loadInterfaceForName will find B.hi even if B is a hidden module,
647 -- and that's what we want.
648 loadInterfaceForName doc name `thenM` \ iface -> do {
649 traceRn (text "lookupFixityRn: looking up name in iface cache and found:" <+>
650 vcat [ppr name, ppr $ mi_fix_fn iface (nameOccName name)]);
651 returnM (mi_fix_fn iface (nameOccName name))
654 doc = ptext SLIT("Checking fixity for") <+> ppr name
657 lookupTyFixityRn :: Located Name -> RnM Fixity
658 lookupTyFixityRn (L loc n) = lookupFixityRn n
661 dataTcOccs :: RdrName -> [RdrName]
662 -- If the input is a data constructor, return both it and a type
663 -- constructor. This is useful when we aren't sure which we are
666 | Just n <- isExact_maybe rdr_name -- Ghastly special case
667 , n `hasKey` consDataConKey = [rdr_name] -- see note below
668 | isDataOcc occ = [rdr_name_tc, rdr_name]
669 | otherwise = [rdr_name]
671 occ = rdrNameOcc rdr_name
672 rdr_name_tc = setRdrNameSpace rdr_name tcName
674 -- If the user typed "[]" or "(,,)", we'll generate an Exact RdrName,
675 -- and setRdrNameSpace generates an Orig, which is fine
676 -- But it's not fine for (:), because there *is* no corresponding type
677 -- constructor. If we generate an Orig tycon for GHC.Base.(:), it'll
678 -- appear to be in scope (because Orig's simply allocate a new name-cache
679 -- entry) and then we get an error when we use dataTcOccs in
680 -- TcRnDriver.tcRnGetInfo. Large sigh.
683 %************************************************************************
686 Dealing with rebindable syntax is driven by the
687 Opt_NoImplicitPrelude dynamic flag.
689 In "deriving" code we don't want to use rebindable syntax
690 so we switch off the flag locally
693 %************************************************************************
695 Haskell 98 says that when you say "3" you get the "fromInteger" from the
696 Standard Prelude, regardless of what is in scope. However, to experiment
697 with having a language that is less coupled to the standard prelude, we're
698 trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
699 happens to be in scope. Then you can
701 import MyPrelude as Prelude
702 to get the desired effect.
704 At the moment this just happens for
705 * fromInteger, fromRational on literals (in expressions and patterns)
706 * negate (in expressions)
707 * minus (arising from n+k patterns)
710 We store the relevant Name in the HsSyn tree, in
711 * HsIntegral/HsFractional/HsIsString
715 respectively. Initially, we just store the "standard" name (PrelNames.fromIntegralName,
716 fromRationalName etc), but the renamer changes this to the appropriate user
717 name if Opt_NoImplicitPrelude is on. That is what lookupSyntaxName does.
719 We treat the orignal (standard) names as free-vars too, because the type checker
720 checks the type of the user thing against the type of the standard thing.
723 lookupSyntaxName :: Name -- The standard name
724 -> RnM (SyntaxExpr Name, FreeVars) -- Possibly a non-standard name
725 lookupSyntaxName std_name
726 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
727 if implicit_prelude then normal_case
729 -- Get the similarly named thing from the local environment
730 lookupOccRn (mkRdrUnqual (nameOccName std_name)) `thenM` \ usr_name ->
731 returnM (HsVar usr_name, unitFV usr_name)
733 normal_case = returnM (HsVar std_name, emptyFVs)
735 lookupSyntaxTable :: [Name] -- Standard names
736 -> RnM (SyntaxTable Name, FreeVars) -- See comments with HsExpr.ReboundNames
737 lookupSyntaxTable std_names
738 = doptM Opt_ImplicitPrelude `thenM` \ implicit_prelude ->
739 if implicit_prelude then normal_case
741 -- Get the similarly named thing from the local environment
742 mappM (lookupOccRn . mkRdrUnqual . nameOccName) std_names `thenM` \ usr_names ->
744 returnM (std_names `zip` map HsVar usr_names, mkFVs usr_names)
746 normal_case = returnM (std_names `zip` map HsVar std_names, emptyFVs)
750 %*********************************************************
754 %*********************************************************
757 newLocalsRn :: [Located RdrName] -> RnM [Name]
758 newLocalsRn rdr_names_w_loc
759 = newUniqueSupply `thenM` \ us ->
760 returnM (zipWith mk rdr_names_w_loc (uniqsFromSupply us))
762 mk (L loc rdr_name) uniq
763 | Just name <- isExact_maybe rdr_name = name
764 -- This happens in code generated by Template Haskell
765 | otherwise = ASSERT2( isUnqual rdr_name, ppr rdr_name )
766 -- We only bind unqualified names here
767 -- lookupRdrEnv doesn't even attempt to look up a qualified RdrName
768 mkInternalName uniq (rdrNameOcc rdr_name) loc
770 ---------------------
771 checkDupAndShadowedRdrNames :: SDoc -> [Located RdrName] -> RnM ()
772 checkDupAndShadowedRdrNames doc loc_rdr_names
773 = do { checkDupRdrNames doc loc_rdr_names
775 ; checkShadowedNames doc envs
776 [(loc,rdrNameOcc rdr) | L loc rdr <- loc_rdr_names] }
778 ---------------------
779 bindLocatedLocalsRn :: SDoc -- Documentation string for error message
783 bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope
784 = checkDupAndShadowedRdrNames doc_str rdr_names_w_loc `thenM_`
786 -- Make fresh Names and extend the environment
787 newLocalsRn rdr_names_w_loc `thenM` \names ->
788 bindLocalNames names (enclosed_scope names)
790 bindLocalNames :: [Name] -> RnM a -> RnM a
791 bindLocalNames names enclosed_scope
792 = getLocalRdrEnv `thenM` \ name_env ->
793 setLocalRdrEnv (extendLocalRdrEnv name_env names)
796 bindLocalNamesFV :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
797 bindLocalNamesFV names enclosed_scope
798 = do { (result, fvs) <- bindLocalNames names enclosed_scope
799 ; returnM (result, delListFromNameSet fvs names) }
802 -------------------------------------
803 -- binLocalsFVRn is the same as bindLocalsRn
804 -- except that it deals with free vars
805 bindLocatedLocalsFV :: SDoc -> [Located RdrName]
806 -> ([Name] -> RnM (a,FreeVars)) -> RnM (a, FreeVars)
807 bindLocatedLocalsFV doc rdr_names enclosed_scope
808 = bindLocatedLocalsRn doc rdr_names $ \ names ->
809 enclosed_scope names `thenM` \ (thing, fvs) ->
810 returnM (thing, delListFromNameSet fvs names)
812 -------------------------------------
813 bindTyVarsRn :: SDoc -> [LHsTyVarBndr RdrName]
814 -> ([LHsTyVarBndr Name] -> RnM a)
816 -- Haskell-98 binding of type variables; e.g. within a data type decl
817 bindTyVarsRn doc_str tyvar_names enclosed_scope
819 located_tyvars = hsLTyVarLocNames tyvar_names
821 bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
822 enclosed_scope (zipWith replace tyvar_names names)
824 replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
826 bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
827 -- Find the type variables in the pattern type
828 -- signatures that must be brought into scope
829 bindPatSigTyVars tys thing_inside
830 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
831 ; if not scoped_tyvars then
834 do { name_env <- getLocalRdrEnv
835 ; let locd_tvs = [ tv | ty <- tys
836 , tv <- extractHsTyRdrTyVars ty
837 , not (unLoc tv `elemLocalRdrEnv` name_env) ]
838 nubbed_tvs = nubBy eqLocated locd_tvs
839 -- The 'nub' is important. For example:
840 -- f (x :: t) (y :: t) = ....
841 -- We don't want to complain about binding t twice!
843 ; bindLocatedLocalsRn doc_sig nubbed_tvs thing_inside }}
845 doc_sig = text "In a pattern type-signature"
847 bindPatSigTyVarsFV :: [LHsType RdrName]
850 bindPatSigTyVarsFV tys thing_inside
851 = bindPatSigTyVars tys $ \ tvs ->
852 thing_inside `thenM` \ (result,fvs) ->
853 returnM (result, fvs `delListFromNameSet` tvs)
855 bindSigTyVarsFV :: [Name]
858 bindSigTyVarsFV tvs thing_inside
859 = do { scoped_tyvars <- doptM Opt_ScopedTypeVariables
860 ; if not scoped_tyvars then
863 bindLocalNamesFV tvs thing_inside }
865 extendTyVarEnvFVRn :: [Name] -> RnM (a, FreeVars) -> RnM (a, FreeVars)
866 -- This function is used only in rnSourceDecl on InstDecl
867 extendTyVarEnvFVRn tyvars thing_inside = bindLocalNamesFV tyvars thing_inside
869 -------------------------------------
870 checkDupRdrNames :: SDoc
873 checkDupRdrNames doc_str rdr_names_w_loc
874 = -- Check for duplicated names in a binding group
875 mappM_ (dupNamesErr getLoc doc_str) dups
877 (_, dups) = removeDups (\n1 n2 -> unLoc n1 `compare` unLoc n2) rdr_names_w_loc
879 checkDupNames :: SDoc
882 checkDupNames doc_str names
883 = -- Check for duplicated names in a binding group
884 mappM_ (dupNamesErr nameSrcSpan doc_str) dups
886 (_, dups) = removeDups (\n1 n2 -> nameOccName n1 `compare` nameOccName n2) names
888 -------------------------------------
889 checkShadowedNames :: SDoc -> (GlobalRdrEnv, LocalRdrEnv) -> [(SrcSpan,OccName)] -> RnM ()
890 checkShadowedNames doc_str (global_env,local_env) loc_rdr_names
891 = ifOptM Opt_WarnNameShadowing $
892 do { traceRn (text "shadow" <+> ppr loc_rdr_names)
893 ; mappM_ check_shadow loc_rdr_names }
895 check_shadow (loc, occ)
896 | Just n <- mb_local = complain [ptext SLIT("bound at") <+> ppr (nameSrcLoc n)]
897 | not (null gres) = complain (map pprNameProvenance gres)
898 | otherwise = return ()
900 complain pp_locs = addWarnAt loc (shadowedNameWarn doc_str occ pp_locs)
901 mb_local = lookupLocalRdrOcc local_env occ
902 gres = lookupGRE_RdrName (mkRdrUnqual occ) global_env
903 -- Make an Unqualified RdrName and look that up, so that
904 -- we don't find any GREs that are in scope qualified-only
908 %************************************************************************
910 \subsection{Free variable manipulation}
912 %************************************************************************
916 mapFvRn f xs = mappM f xs `thenM` \ stuff ->
918 (ys, fvs_s) = unzip stuff
920 returnM (ys, plusFVs fvs_s)
922 -- because some of the rename functions are CPSed:
923 -- maps the function across the list from left to right;
924 -- collects all the free vars into one set
925 mapFvRnCPS :: (a -> (b -> RnM c) -> RnM c)
926 -> [a] -> ([b] -> RnM c) -> RnM c
928 mapFvRnCPS _ [] cont = cont []
929 mapFvRnCPS f (x:xs) cont = f x $ \ x' ->
930 mapFvRnCPS f xs $ \ xs' ->
935 %************************************************************************
937 \subsection{Envt utility functions}
939 %************************************************************************
942 warnUnusedModules :: [(ModuleName,SrcSpan)] -> RnM ()
943 warnUnusedModules mods
944 = ifOptM Opt_WarnUnusedImports (mappM_ bleat mods)
946 bleat (mod,loc) = addWarnAt loc (mk_warn mod)
947 mk_warn m = vcat [ptext SLIT("Module") <+> quotes (ppr m)
948 <+> text "is imported, but nothing from it is used,",
949 nest 2 (ptext SLIT("except perhaps instances visible in")
951 ptext SLIT("To suppress this warning, use:")
952 <+> ptext SLIT("import") <+> ppr m <> parens empty ]
955 warnUnusedImports, warnUnusedTopBinds :: [GlobalRdrElt] -> RnM ()
956 warnUnusedImports gres = ifOptM Opt_WarnUnusedImports (warnUnusedGREs gres)
957 warnUnusedTopBinds gres = ifOptM Opt_WarnUnusedBinds (warnUnusedGREs gres)
959 warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> FreeVars -> RnM ()
960 warnUnusedLocalBinds = check_unused Opt_WarnUnusedBinds
961 warnUnusedMatches = check_unused Opt_WarnUnusedMatches
963 check_unused :: DynFlag -> [Name] -> FreeVars -> RnM ()
964 check_unused flag bound_names used_names
965 = ifOptM flag (warnUnusedLocals (filterOut (`elemNameSet` used_names) bound_names))
967 -------------------------
970 = warnUnusedBinds [(n,p) | GRE {gre_name = n, gre_prov = p} <- gres]
972 warnUnusedLocals names
973 = warnUnusedBinds [(n,LocalDef) | n<-names]
975 warnUnusedBinds :: [(Name,Provenance)] -> RnM ()
976 warnUnusedBinds names = mappM_ warnUnusedName (filter reportable names)
977 where reportable (name,_)
978 | isWiredInName name = False -- Don't report unused wired-in names
979 -- Otherwise we get a zillion warnings
981 | otherwise = reportIfUnused (nameOccName name)
983 -------------------------
985 warnUnusedName :: (Name, Provenance) -> RnM ()
986 warnUnusedName (name, LocalDef)
987 = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
988 (ptext SLIT("Defined but not used"))
990 warnUnusedName (name, Imported is)
993 warn spec = addUnusedWarning name span msg
995 span = importSpecLoc spec
996 pp_mod = quotes (ppr (importSpecModule spec))
997 msg = ptext SLIT("Imported from") <+> pp_mod <+> ptext SLIT("but not used")
999 addUnusedWarning name span msg
1002 nest 2 $ pprNonVarNameSpace (occNameSpace (nameOccName name))
1003 <+> quotes (ppr name)]
1007 addNameClashErrRn rdr_name names
1008 = addErr (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name),
1009 ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)])
1012 msg1 = ptext SLIT("either") <+> mk_ref np1
1013 msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps]
1014 mk_ref gre = quotes (ppr (gre_name gre)) <> comma <+> pprNameProvenance gre
1016 shadowedNameWarn doc occ shadowed_locs
1017 = sep [ptext SLIT("This binding for") <+> quotes (ppr occ)
1018 <+> ptext SLIT("shadows the existing binding") <> plural shadowed_locs,
1019 nest 2 (vcat shadowed_locs)]
1022 unknownNameErr rdr_name
1023 = vcat [ hang (ptext SLIT("Not in scope:"))
1024 2 (pprNonVarNameSpace (occNameSpace (rdrNameOcc rdr_name))
1025 <+> quotes (ppr rdr_name))
1028 extra | rdr_name == forall_tv_RDR
1029 = ptext SLIT("Perhaps you intended to use -XRankNTypes or similar flag")
1032 unknownSubordinateErr doc op -- Doc is "method of class" or
1033 -- "field of constructor"
1034 = quotes (ppr op) <+> ptext SLIT("is not a (visible)") <+> doc
1037 = ptext SLIT("Illegal binding of built-in syntax:") <+> ppr (rdrNameOcc name)
1038 -- The rdrNameOcc is because we don't want to print Prelude.(,)
1040 dupNamesErr :: Outputable n => (n -> SrcSpan) -> SDoc -> [n] -> RnM ()
1041 dupNamesErr get_loc descriptor names
1042 = addErrAt big_loc $
1043 vcat [ptext SLIT("Conflicting definitions for") <+> quotes (ppr (head names)),
1044 locations, descriptor]
1046 locs = map get_loc names
1047 big_loc = foldr1 combineSrcSpans locs
1048 one_line = isOneLineSpan big_loc
1049 locations | one_line = empty
1050 | otherwise = ptext SLIT("Bound at:") <+>
1051 vcat (map ppr (sortLe (<=) locs))
1053 badQualBndrErr rdr_name
1054 = ptext SLIT("Qualified name in binding position:") <+> ppr rdr_name