getImportedRules, loadHomeInterface, getSlurped, removeContext
)
import RnEnv ( availName, availNames, availsToNameSet,
- warnUnusedTopNames, mapFvRn, lookupImplicitOccRn,
+ warnUnusedImports, warnUnusedLocalBinds, mapFvRn, lookupImplicitOccRn,
FreeVars, plusFVs, plusFV, unitFV, emptyFVs, isEmptyFVs
)
import Module ( Module, ModuleName, pprModule, mkSearchPath, mkThisModule )
import Name ( Name, isLocallyDefined,
NamedThing(..), ImportReason(..), Provenance(..),
- pprOccName, nameOccName,
- getNameProvenance,
+ pprOccName, nameOccName, nameUnique,
+ getNameProvenance, isUserImportedExplicitlyName,
maybeWiredInTyConName, maybeWiredInIdName, isWiredInName
)
import Id ( idType )
import NameSet
import PrelMods ( mAIN_Name, pREL_MAIN_Name )
import TysWiredIn ( unitTyCon, intTyCon, doubleTyCon, boolTyCon )
-import PrelInfo ( ioTyCon_NAME, numClass_RDR, thinAirIdNames, derivingOccurrences )
+import PrelInfo ( ioTyCon_NAME, thinAirIdNames, fractionalClassKeys, derivingOccurrences )
import Type ( namesOfType, funTyCon )
-import ErrUtils ( pprBagOfErrors, pprBagOfWarnings,
- doIfSet, dumpIfSet, ghcExit
- )
+import ErrUtils ( printErrorsAndWarnings, dumpIfSet, ghcExit )
import BasicTypes ( NewOrData(..) )
import Bag ( isEmptyBag, bagToList )
import FiniteMap ( fmToList, delListFromFM, addToFM, sizeFM, eltsFM )
import UniqFM ( lookupUFM )
import Util ( equivClasses )
import Maybes ( maybeToBool )
+import SrcLoc ( mkBuiltinSrcLoc )
import Outputable
\end{code}
= -- Initialise the renamer monad
initRn mod_name us (mkSearchPath opt_HiMap) loc
(rename this_mod) >>=
- \ (maybe_rn_stuff, rn_errs_bag, rn_warns_bag) ->
+ \ ((maybe_rn_stuff, dump_action), rn_errs_bag, rn_warns_bag) ->
-- Check for warnings
- doIfSet (not (isEmptyBag rn_warns_bag))
- (printErrs (pprBagOfWarnings rn_warns_bag)) >>
-
- -- Check for errors; exit if so
- doIfSet (not (isEmptyBag rn_errs_bag))
- (printErrs (pprBagOfErrors rn_errs_bag) >>
- ghcExit 1
- ) >>
-
- -- Dump output, if any
- (case maybe_rn_stuff of
- Nothing -> return ()
- Just results@(_, rn_mod, _, _, _)
- -> dumpIfSet opt_D_dump_rn "Renamer:"
- (ppr rn_mod)
- ) >>
+ printErrorsAndWarnings rn_errs_bag rn_warns_bag >>
+
+ -- Dump any debugging output
+ dump_action >>
-- Return results
- return maybe_rn_stuff
+ if not (isEmptyBag rn_errs_bag) then
+ ghcExit 1 >> return Nothing
+ else
+ return maybe_rn_stuff
\end{code}
\begin{code}
-rename this_mod@(HsModule mod_name vers exports imports local_decls loc)
+rename this_mod@(HsModule mod_name vers _ imports local_decls loc)
= -- FIND THE GLOBAL NAME ENVIRONMENT
getGlobalNames this_mod `thenRn` \ maybe_stuff ->
-- CHECK FOR EARLY EXIT
if not (maybeToBool maybe_stuff) then
-- Everything is up to date; no need to recompile further
- rnStats [] `thenRn_`
- returnRn Nothing
+ rnDump [] [] `thenRn` \ dump_action ->
+ returnRn (Nothing, dump_action)
else
let
Just (export_env, gbl_env, fixity_env, global_avail_env) = maybe_stuff
-- override the implicit ones.
in
slurpImpDecls real_source_fvs `thenRn` \ rn_imp_decls ->
+ let
+ rn_all_decls = rn_local_decls ++ rn_imp_decls
+ in
-- EXIT IF ERRORS FOUND
- checkErrsRn `thenRn` \ no_errs_so_far ->
+ checkErrsRn `thenRn` \ no_errs_so_far ->
if not no_errs_so_far then
-- Found errors already, so exit now
- rnStats [] `thenRn_`
- returnRn Nothing
+ rnDump rn_imp_decls rn_all_decls `thenRn` \ dump_action ->
+ returnRn (Nothing, dump_action)
else
-- GENERATE THE VERSION/USAGE INFO
- getImportVersions mod_name exports `thenRn` \ my_usages ->
- getNameSupplyRn `thenRn` \ name_supply ->
+ getImportVersions mod_name export_env `thenRn` \ my_usages ->
+ getNameSupplyRn `thenRn` \ name_supply ->
-- REPORT UNUSED NAMES
reportUnusedNames gbl_env global_avail_env
let
has_orphans = any isOrphanDecl rn_local_decls
direct_import_mods = [mod | ImportDecl mod _ _ _ _ _ <- imports]
- rn_all_decls = rn_imp_decls ++ rn_local_decls
renamed_module = HsModule mod_name vers
trashed_exports trashed_imports
rn_all_decls
loc
in
- rnStats rn_imp_decls `thenRn_`
+ rnDump rn_imp_decls rn_all_decls `thenRn` \ dump_action ->
returnRn (Just (mkThisModule mod_name,
renamed_module,
(has_orphans, my_usages, export_env),
name_supply,
- direct_import_mods))
+ direct_import_mods), dump_action)
where
trashed_exports = {-trace "rnSource:trashed_exports"-} Nothing
trashed_imports = {-trace "rnSource:trashed_imports"-} []
\begin{code}
implicitFVs mod_name decls
= mapRn lookupImplicitOccRn implicit_occs `thenRn` \ implicit_names ->
- returnRn (implicit_main `plusFV`
- mkNameSet default_tys `plusFV`
- mkNameSet thinAirIdNames `plusFV`
+ returnRn (implicit_main `plusFV`
+ mkNameSet (map getName default_tycons) `plusFV`
+ mkNameSet thinAirIdNames `plusFV`
mkNameSet implicit_names)
-
where
- -- Add occurrences for Int, Double, and (), because they
+ -- Add occurrences for Int, and (), because they
-- are the types to which ambigious type variables may be defaulted by
-- the type checker; so they won't always appear explicitly.
-- [The () one is a GHC extension for defaulting CCall results.]
-- ALSO: funTyCon, since it occurs implicitly everywhere!
-- (we don't want to be bothered with making funTyCon a
-- free var at every function application!)
- default_tys = [getName intTyCon, getName doubleTyCon,
- getName unitTyCon, getName funTyCon, getName boolTyCon]
+ -- Double is dealt with separately in getGates
+ default_tycons = [unitTyCon, funTyCon, boolTyCon, intTyCon]
-- Add occurrences for IO or PrimIO
implicit_main | mod_name == mAIN_Name
-- generate code
implicit_occs = foldr ((++) . get) [] decls
- get (DefD _) = [numClass_RDR]
get (TyClD (TyData _ _ _ _ _ (Just deriv_classes) _ _))
= concat (map get_deriv deriv_classes)
get other = []
isOrphanDecl (RuleD (RuleDecl _ _ _ lhs _ _))
= check lhs
where
- check (HsVar v) = not (isLocallyDefined v)
- check (HsApp f a) = check f && check a
- check other = True
+ -- At the moment we just check for common LHS forms
+ -- Expand as necessary. Getting it wrong just means
+ -- more orphans than necessary
+ check (HsVar v) = not (isLocallyDefined v)
+ check (HsApp f a) = check f && check a
+ check (HsLit _) = False
+ check (OpApp l o _ r) = check l && check o && check r
+ check (NegApp e _) = check e
+ check (HsPar e) = check e
+ check (SectionL e o) = check e && check o
+ check (SectionR o e) = check e && check o
+
+ check other = True -- Safe fall through
+
isOrphanDecl other = False
\end{code}
+\begin{code}
+dupDefaultDeclErrRn (DefaultDecl _ locn1 : dup_things)
+ = pushSrcLocRn locn1 $
+ addErrRn msg
+ where
+ msg = hang (ptext SLIT("Multiple default declarations"))
+ 4 (vcat (map pp dup_things))
+ pp (DefaultDecl _ locn) = ptext SLIT("here was another default declaration") <+> ppr locn
+\end{code}
+
+
%*********************************************************
%* *
\subsection{Slurping declarations}
-- The current slurped-set records all local things
getSlurped `thenRn` \ source_binders ->
- slurpSourceRefs source_binders source_fvs `thenRn` \ (decls1, needed1, inst_gates) ->
-
- -- Now we can get the instance decls
- slurpInstDecls decls1 needed1 inst_gates `thenRn` \ (decls2, needed2) ->
+ slurpSourceRefs source_binders source_fvs `thenRn` \ (decls, needed) ->
-- And finally get everything else
- closeDecls decls2 needed2
+ closeDecls decls needed
-------------------------------------------------------
slurpSourceRefs :: NameSet -- Variables defined in source
-> FreeVars -- Variables referenced in source
-> RnMG ([RenamedHsDecl],
- FreeVars, -- Un-satisfied needs
- FreeVars) -- "Gates"
+ FreeVars) -- Un-satisfied needs
-- The declaration (and hence home module) of each gate has
-- already been loaded
slurpSourceRefs source_binders source_fvs
- = go [] -- Accumulating decls
- emptyFVs -- Unsatisfied needs
- source_fvs -- Accumulating gates
- (nameSetToList source_fvs) -- Gates whose defn hasn't been loaded yet
+ = go_outer [] -- Accumulating decls
+ emptyFVs -- Unsatisfied needs
+ emptyFVs -- Accumulating gates
+ (nameSetToList source_fvs) -- Things whose defn hasn't been loaded yet
where
- go decls fvs gates []
+ -- The outer loop repeatedly slurps the decls for the current gates
+ -- and the instance decls
+
+ -- The outer loop is needed because consider
+ -- instance Foo a => Baz (Maybe a) where ...
+ -- It may be that @Baz@ and @Maybe@ are used in the source module,
+ -- but not @Foo@; so we need to chase @Foo@ too.
+ --
+ -- We also need to follow superclass refs. In particular, 'chasing @Foo@' must
+ -- include actually getting in Foo's class decl
+ -- class Wib a => Foo a where ..
+ -- so that its superclasses are discovered. The point is that Wib is a gate too.
+ -- We do this for tycons too, so that we look through type synonyms.
+
+ go_outer decls fvs all_gates []
+ = returnRn (decls, fvs)
+
+ go_outer decls fvs all_gates refs -- refs are not necessarily slurped yet
+ = traceRn (text "go_outer" <+> ppr refs) `thenRn_`
+ go_inner decls fvs emptyFVs refs `thenRn` \ (decls1, fvs1, gates1) ->
+ getImportedInstDecls (all_gates `plusFV` gates1) `thenRn` \ inst_decls ->
+ rnInstDecls decls1 fvs1 gates1 inst_decls `thenRn` \ (decls2, fvs2, gates2) ->
+ go_outer decls2 fvs2 (all_gates `plusFV` gates2)
+ (nameSetToList (gates2 `minusNameSet` all_gates))
+ -- Knock out the all_gates because even if we don't slurp any new
+ -- decls we can get some apparently-new gates from wired-in names
+
+ go_inner decls fvs gates []
= returnRn (decls, fvs, gates)
- go decls fvs gates (wanted_name:refs)
+ go_inner decls fvs gates (wanted_name:refs)
| isWiredInName wanted_name
= load_home wanted_name `thenRn_`
- go decls fvs (gates `plusFV` getWiredInGates wanted_name) refs
+ go_inner decls fvs (gates `plusFV` getWiredInGates wanted_name) refs
| otherwise
= importDecl wanted_name `thenRn` \ maybe_decl ->
case maybe_decl of
- -- No declaration... (already slurped, or local)
- Nothing -> go decls fvs gates refs
+ Nothing -> go_inner decls fvs gates refs -- No declaration... (already slurped, or local)
Just decl -> rnIfaceDecl decl `thenRn` \ (new_decl, fvs1) ->
- let
- new_gates = getGates source_fvs new_decl
- in
- go (new_decl : decls)
- (fvs1 `plusFV` fvs)
- (gates `plusFV` new_gates)
- (nameSetToList new_gates ++ refs)
+ go_inner (new_decl : decls)
+ (fvs1 `plusFV` fvs)
+ (gates `plusFV` getGates source_fvs new_decl)
+ refs
-- When we find a wired-in name we must load its
-- home module so that we find any instance decls therein
returnRn ()
where
doc = ptext SLIT("need home module for wired in thing") <+> ppr name
-\end{code}
-%
-@slurpInstDecls@ imports appropriate instance decls.
-It has to incorporate a loop, because consider
-\begin{verbatim}
- instance Foo a => Baz (Maybe a) where ...
-\end{verbatim}
-It may be that @Baz@ and @Maybe@ are used in the source module,
-but not @Foo@; so we need to chase @Foo@ too.
-\begin{code}
-slurpInstDecls decls needed gates
- | isEmptyFVs gates
- = returnRn (decls, needed)
+rnInstDecls decls fvs gates []
+ = returnRn (decls, fvs, gates)
+rnInstDecls decls fvs gates (d:ds)
+ = rnIfaceDecl d `thenRn` \ (new_decl, fvs1) ->
+ rnInstDecls (new_decl:decls)
+ (fvs1 `plusFV` fvs)
+ (gates `plusFV` getInstDeclGates new_decl)
+ ds
+\end{code}
- | otherwise
- = getImportedInstDecls gates `thenRn` \ inst_decls ->
- rnInstDecls decls needed emptyFVs inst_decls `thenRn` \ (decls1, needed1, gates1) ->
- slurpInstDecls decls1 needed1 gates1
- where
- rnInstDecls decls fvs gates []
- = returnRn (decls, fvs, gates)
- rnInstDecls decls fvs gates (d:ds)
- = rnIfaceDecl d `thenRn` \ (new_decl, fvs1) ->
- rnInstDecls (new_decl:decls)
- (fvs1 `plusFV` fvs)
- (gates `plusFV` getInstDeclGates new_decl)
- ds
-
+\begin{code}
-------------------------------------------------------
-- closeDecls keeps going until the free-var set is empty
closeDecls decls needed
getGates source_fvs (SigD (IfaceSig _ ty _ _))
= extractHsTyNames ty
-getGates source_fvs (TyClD (ClassDecl ctxt cls tvs sigs _ _ _ _ _ _))
- = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
+getGates source_fvs (TyClD (ClassDecl ctxt cls tvs _ sigs _ _ _ _ _ _))
+ = (delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
(map getTyVarName tvs)
- `addOneToNameSet` cls
+ `addOneToNameSet` cls)
+ `plusFV` maybe_double
where
- get (ClassOpSig n _ ty _)
+ get (ClassOpSig n _ _ ty _)
| n `elemNameSet` source_fvs = extractHsTyNames ty
| otherwise = emptyFVs
+ -- If we load any numeric class that doesn't have
+ -- Int as an instance, add Double to the gates.
+ -- This takes account of the fact that Double might be needed for
+ -- defaulting, but we don't want to load Double (and all its baggage)
+ -- if the more exotic classes aren't used at all.
+ maybe_double | nameUnique cls `elem` fractionalClassKeys
+ = unitFV (getName doubleTyCon)
+ | otherwise
+ = emptyFVs
+
getGates source_fvs (TyClD (TySynonym tycon tvs ty _))
= delListFromNameSet (extractHsTyNames ty)
(map getTyVarName tvs)
%*********************************************************
\begin{code}
-reportUnusedNames gbl_env avail_env (ExportEnv export_avails _) mentioned_names
+reportUnusedNames gbl_env avail_env (ExportEnv export_avails _ _) mentioned_names
= let
used_names = mentioned_names `unionNameSets` availsToNameSet export_avails
nameSetToList (defined_names `minusNameSet` really_used_names)
-- Filter out the ones only defined implicitly
- bad_guys = filter reportableUnusedName defined_but_not_used
+ bad_locals = [n | n <- defined_but_not_used, isLocallyDefined n]
+ bad_imps = [n | n <- defined_but_not_used, isUserImportedExplicitlyName n]
in
- warnUnusedTopNames bad_guys
+ warnUnusedLocalBinds bad_locals `thenRn_`
+ warnUnusedImports bad_imps
-reportableUnusedName :: Name -> Bool
-reportableUnusedName name
- = explicitlyImported (getNameProvenance name)
- where
- explicitlyImported (LocalDef _ _) = True
- -- Report unused defns of local vars
- explicitlyImported (NonLocalDef (UserImport _ _ expl) _) = expl
- -- Report unused explicit imports
- explicitlyImported other = False
- -- Don't report others
-
-rnStats :: [RenamedHsDecl] -> RnMG ()
-rnStats imp_decls
+rnDump :: [RenamedHsDecl] -- Renamed imported decls
+ -> [RenamedHsDecl] -- Renamed local decls
+ -> RnMG (IO ())
+rnDump imp_decls decls
| opt_D_dump_rn_trace ||
opt_D_dump_rn_stats ||
opt_D_dump_rn
- = getRnStats imp_decls `thenRn` \ msg ->
- ioToRnM (printErrs msg) `thenRn_`
- returnRn ()
+ = getRnStats imp_decls `thenRn` \ stats_msg ->
- | otherwise = returnRn ()
-\end{code}
+ returnRn (printErrs stats_msg >>
+ dumpIfSet opt_D_dump_rn "Renamer:" (vcat (map ppr decls)))
+ | otherwise = returnRn (return ())
+\end{code}
%*********************************************************
projects / ghc-hetmet.git / blobdiff