X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FRename.lhs;h=bd51090149b8cbfe7239ef94ef8c7151aaeae640;hb=d551a33a685f53d5285ba45538aa6fdfc3cb8c7e;hp=3b7cdf2c86fc1f927d16b96228e0d6e4b584911e;hpb=6c381e873e222417d9a67aeec77b9555eca7b7a8;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/Rename.lhs b/ghc/compiler/rename/Rename.lhs index 3b7cdf2..bd51090 100644 --- a/ghc/compiler/rename/Rename.lhs +++ b/ghc/compiler/rename/Rename.lhs @@ -8,115 +8,307 @@ module Rename ( renameModule ) where -import Ubiq{-uitous-} +#if __GLASGOW_HASKELL__ <= 201 +import PreludeGlaST ( thenPrimIO ) +#else +import GlaExts +import IO +#endif + +IMP_Ubiq() +IMPORT_1_3(List(partition)) import HsSyn -import RdrHsSyn ( ProtoNameHsModule(..) ) -import RnHsSyn ( RenamedHsModule(..) ) - -import Bag ( isEmptyBag, unionBags ) -import CmdLineOpts ( opt_UseGetMentionedVars ) -import ErrUtils ( Error(..) ) -import Pretty ( Pretty(..){-ToDo:rm?-} ) -import RnMonad12 ( initRn12 ) -import RnMonad4 ( initRn4 ) -import RnPass1 -import RnPass2 -import RnPass3 -import RnPass4 -import RnUtils ( PreludeNameMappers(..), GlobalNameMappers(..) ) -import UniqSupply ( splitUniqSupply ) -import Util ( panic ) +import RdrHsSyn ( RdrName(..), SYN_IE(RdrNameHsModule), SYN_IE(RdrNameImportDecl) ) +import RnHsSyn ( SYN_IE(RenamedHsModule), SYN_IE(RenamedHsDecl), extractHsTyNames ) + +import CmdLineOpts ( opt_HiMap, opt_WarnNameShadowing, opt_D_show_rn_trace, + opt_D_dump_rn, opt_D_show_rn_stats, + opt_D_show_unused_imports, opt_PprUserLength + ) +import RnMonad +import RnNames ( getGlobalNames ) +import RnSource ( rnDecl ) +import RnIfaces ( getImportedInstDecls, importDecl, getImportVersions, getSpecialInstModules, + getDeferredDataDecls, + mkSearchPath, getSlurpedNames, getRnStats + ) +import RnEnv ( availsToNameSet, addAvailToNameSet, + addImplicitOccsRn, lookupImplicitOccRn ) +import Id ( GenId {- instance NamedThing -} ) +import Name ( Name, Provenance, ExportFlag(..), isLocallyDefined, + NameSet(..), elemNameSet, mkNameSet, unionNameSets, + nameSetToList, minusNameSet, NamedThing(..), + nameModule, pprModule, pprOccName, nameOccName + ) +import TysWiredIn ( unitTyCon, intTyCon, doubleTyCon ) +import TyCon ( TyCon ) +import PrelMods ( mAIN, gHC_MAIN ) +import PrelInfo ( ioTyCon_NAME ) +import ErrUtils ( SYN_IE(Error), SYN_IE(Warning), pprBagOfErrors, + doIfSet, dumpIfSet, ghcExit + ) +import FiniteMap ( emptyFM, eltsFM, fmToList, addToFM, FiniteMap ) +import Pretty +import Outputable ( Outputable(..), PprStyle(..), + pprErrorsStyle, pprDumpStyle, printErrs + ) +import Bag ( isEmptyBag ) +import Util ( cmpPString, equivClasses, panic, assertPanic, pprTrace ) +#if __GLASGOW_HASKELL__ >= 202 +import UniqSupply +#endif +\end{code} + + + +\begin{code} +renameModule :: UniqSupply + -> RdrNameHsModule + -> IO (Maybe (RenamedHsModule, -- Output, after renaming + InterfaceDetails, -- Interface; for interface file generatino + RnNameSupply, -- Final env; for renaming derivings + [Module])) -- Imported modules; for profiling + +renameModule us this_mod@(HsModule mod_name vers exports imports fixities local_decls loc) + = -- Initialise the renamer monad + initRn mod_name us (mkSearchPath opt_HiMap) loc + (rename this_mod) >>= + \ (maybe_rn_stuff, rn_errs_bag, rn_warns_bag) -> + + -- Check for warnings + doIfSet (not (isEmptyBag rn_warns_bag)) + (print_errs rn_warns_bag) >> + + -- Check for errors; exit if so + doIfSet (not (isEmptyBag rn_errs_bag)) + (print_errs 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 pprDumpStyle rn_mod) + ) >> + + -- Return results + return maybe_rn_stuff + + +print_errs errs = printErrs (pprBagOfErrors pprErrorsStyle errs) \end{code} -Here's what the renamer does, basically: -\begin{description} -\item[@RnPass1@:] -Flattens out the declarations from the interfaces which this module -imports. The result is a new module with no imports, but with more -declarations. (Obviously, the imported declarations have ``funny -names'' [@ProtoNames@] to indicate their origin.) Handles selective -import, renaming, \& such. - -%-------------------------------------------------------------------- -\item[@RnPass2@:] -Removes duplicate declarations. Duplicates can arise when two -imported interface have a signature (or whatever) for the same -thing. We check that the two are consistent and then drop one. -Considerable huff and puff to pick the one with the ``better'' -pragmatic information. - -%-------------------------------------------------------------------- -\item[@RnPass3@:] -Find all the top-level-ish (i.e., global) entities, assign them -@Uniques@, and make a \tr{ProtoName -> Name} mapping for them, -in preparation for... - -%-------------------------------------------------------------------- -\item[@RnPass4@:] -Actually prepare the ``renamed'' module. In sticking @Names@ on -everything, it will catch out-of-scope errors (and a couple of similar -type-variable-use errors). We also our initial dependency analysis of -the program (required before typechecking). -\end{description} \begin{code} -renameModule :: PreludeNameMappers -- lookup funs for deeply wired-in names - -> ProtoNameHsModule -- input - -> UniqSupply - -> (RenamedHsModule, -- output, after renaming - Bag FAST_STRING, -- Names of the imported modules - -- (profiling needs to know this) - GlobalNameMappers, -- final name funs; used later - -- to rename generated `deriving' - -- bindings. - Bag Error -- Errors, from passes 1-4 - ) - --- Very space-leak sensitive - -renameModule gnfs@(val_pnf, tc_pnf) - input@(HsModule mod_name _ _ _ _ _ _ _ _ _ _ _ _) - uniqs - = let - use_mentioned_vars = opt_UseGetMentionedVars +rename this_mod@(HsModule mod_name vers exports imports fixities local_decls loc) + = -- FIND THE GLOBAL NAME ENVIRONMENT + getGlobalNames this_mod `thenRn` \ global_name_info -> + + case global_name_info of { + Nothing -> -- Everything is up to date; no need to recompile further + rnStats [] `thenRn_` + returnRn Nothing ; + + -- Otherwise, just carry on + Just (export_env, rn_env, explicit_names) -> + + -- RENAME THE SOURCE + initRnMS rn_env mod_name SourceMode ( + addImplicits mod_name `thenRn_` + mapRn rnDecl local_decls + ) `thenRn` \ rn_local_decls -> + + -- SLURP IN ALL THE NEEDED DECLARATIONS + slurpDecls rn_local_decls `thenRn` \ rn_all_decls -> + + + -- GENERATE THE VERSION/USAGE INFO + getImportVersions mod_name exports `thenRn` \ import_versions -> + getNameSupplyRn `thenRn` \ name_supply -> + + -- REPORT UNUSED NAMES + reportUnusedNames explicit_names `thenRn_` + + -- GENERATE THE SPECIAL-INSTANCE MODULE LIST + -- The "special instance" modules are those modules that contain instance + -- declarations that contain no type constructor or class that was declared + -- in that module. + getSpecialInstModules `thenRn` \ imported_special_inst_mods -> + let + special_inst_decls = [d | InstD d@(InstDecl inst_ty _ _ _ _) <- rn_local_decls, + all (not.isLocallyDefined) (nameSetToList (extractHsTyNames inst_ty)) + ] + special_inst_mods | null special_inst_decls = imported_special_inst_mods + | otherwise = mod_name : imported_special_inst_mods in - case (initRn12 mod_name (rnModule1 gnfs use_mentioned_vars input)) - of { ((mod1, imported_module_names), errs1) -> + + + -- RETURN THE RENAMED MODULE + let + import_mods = [mod | ImportDecl mod _ _ _ _ _ <- imports] - case (initRn12 mod_name (rnModule2 mod1)) of { (mod2, errs2) -> + renamed_module = HsModule mod_name vers + trashed_exports trashed_imports trashed_fixities + rn_all_decls + loc + in + rnStats rn_all_decls `thenRn_` + returnRn (Just (renamed_module, + (import_versions, export_env, special_inst_mods), + name_supply, + import_mods)) + } + where + trashed_exports = {-trace "rnSource:trashed_exports"-} Nothing + trashed_imports = {-trace "rnSource:trashed_imports"-} [] + trashed_fixities = [] +\end{code} - case (splitUniqSupply uniqs) of { (us1, us2) -> +@addImplicits@ forces the renamer to slurp in some things which aren't +mentioned explicitly, but which might be needed by the type checker. - case (initRn3 (rnModule3 gnfs imported_module_names mod2) us1) - of { (val_space, tc_space, v_gnf, tc_gnf, errs3) -> +\begin{code} +addImplicits mod_name + = addImplicitOccsRn (implicit_main ++ default_tys) + where + -- Add occurrences for Int, Double, and (), because they + -- are the types to which ambigious type variables may be defaulted by + -- the type checker; so they won't every appear explicitly. + -- [The () one is a GHC extension for defaulting CCall results.] + default_tys = [getName intTyCon, getName doubleTyCon, getName unitTyCon ] + -- Add occurrences for IO or PrimIO + implicit_main | mod_name == mAIN + || mod_name == gHC_MAIN = [ioTyCon_NAME] + | otherwise = [] +\end{code} + + +\begin{code} +slurpDecls decls + = -- First of all, get all the compulsory decls + slurp_compulsories decls `thenRn` \ decls1 -> + + -- Next get the optional ones + closeDecls Optional decls1 `thenRn` \ decls2 -> + + -- Finally get those deferred data type declarations + getDeferredDataDecls `thenRn` \ data_decls -> + mapRn rn_data_decl data_decls `thenRn` \ rn_data_decls -> + + -- Done + returnRn (rn_data_decls ++ decls2) + + where + -- The "slurp_compulsories" function is a loop that alternates + -- between slurping compulsory decls and slurping the instance + -- decls thus made relavant. + -- We *must* loop again here. Why? Two reasons: + -- (a) an instance decl will give rise to an unresolved dfun, whose + -- decl we must slurp to get its version number; that's the version + -- number for the whole instance decl. (And its unfolding might mention new + -- unresolved names.) + -- (b) an instance decl might give rise to a new unresolved class, + -- whose decl we must slurp, which might let in some new instance decls, + -- and so on. Example: instance Foo a => Baz [a] where ... + slurp_compulsories decls + = closeDecls Compulsory decls `thenRn` \ decls1 -> + + -- Instance decls still pending? + getImportedInstDecls `thenRn` \ inst_decls -> + if null inst_decls then + -- No, none + returnRn decls1 + else + -- Yes, there are some, so rename them and loop + traceRn (sep [ptext SLIT("Slurped"), int (length inst_decls), ptext SLIT("instance decls")]) + `thenRn_` + mapRn rn_inst_decl inst_decls `thenRn` \ new_inst_decls -> + slurp_compulsories (new_inst_decls ++ decls1) +\end{code} + +\begin{code} +closeDecls :: Necessity + -> [RenamedHsDecl] -- Declarations got so far + -> RnMG [RenamedHsDecl] -- input + extra decls slurped + -- The monad includes a list of possibly-unresolved Names + -- This list is empty when closeDecls returns + +closeDecls necessity decls + = popOccurrenceName necessity `thenRn` \ maybe_unresolved -> + case maybe_unresolved of + + -- No more unresolved names + Nothing -> returnRn decls + + -- An unresolved name + Just name + -> -- Slurp its declaration, if any +-- traceRn (sep [ptext SLIT("Considering"), ppr PprDebug name]) `thenRn_` + importDecl name necessity `thenRn` \ maybe_decl -> + case maybe_decl of + + -- No declaration... (wired in thing or optional) + Nothing -> closeDecls necessity decls + + -- Found a declaration... rename it + Just decl -> rn_iface_decl mod_name necessity decl `thenRn` \ new_decl -> + closeDecls necessity (new_decl : decls) + where + mod_name = nameModule name + + +rn_iface_decl mod_name necessity decl -- Notice that the rnEnv starts empty + = initRnMS emptyRnEnv mod_name (InterfaceMode necessity) (rnDecl decl) + +rn_inst_decl (mod_name,decl) = rn_iface_decl mod_name Compulsory (InstD decl) + +rn_data_decl (tycon_name,ty_decl) = rn_iface_decl mod_name Compulsory (TyD ty_decl) + where + mod_name = nameModule tycon_name +\end{code} + +\begin{code} +reportUnusedNames explicit_avail_names + | not opt_D_show_unused_imports + = returnRn () + + | otherwise + = getSlurpedNames `thenRn` \ slurped_names -> let - final_name_funs = (v_gnf, tc_gnf) + unused = explicit_avail_names `minusNameSet` slurped_names + (local_unused, imported_unused) = partition isLocallyDefined (nameSetToList unused) + imports_by_module = equivClasses cmp imported_unused + name1 `cmp` name2 = nameModule name1 `_CMP_STRING_` nameModule name2 + + pp_imp sty = sep [text "For information: the following unqualified imports are unused:", + nest 4 (vcat (map (pp_group sty) imports_by_module))] + pp_group sty (n:ns) = sep [hcat [text "Module ", pprModule (PprForUser opt_PprUserLength) (nameModule n), char ':'], + nest 4 (sep (map (pprOccName sty . nameOccName) (n:ns)))] - errs_so_far = errs1 `unionBags` errs2 `unionBags` errs3 - -- see note below about why we consult errs at this pt + pp_local sty = sep [text "For information: the following local top-level definitions are unused:", + nest 4 (sep (map (pprOccName sty . nameOccName) local_unused))] in - if not (isEmptyBag errs_so_far) then -- give up now - ( panic "rename", imported_module_names, final_name_funs, errs_so_far ) - else - case (initRn4 final_name_funs (rnModule mod2) us2) - of { (mod4, errs4) -> - - ( mod4, imported_module_names, final_name_funs, errs4 ) } - }}}} + (if null imported_unused + then returnRn () + else addWarnRn pp_imp) `thenRn_` + + (if null local_unused + then returnRn () + else addWarnRn pp_local) + +rnStats :: [RenamedHsDecl] -> RnMG () +rnStats all_decls + | opt_D_show_rn_trace || + opt_D_show_rn_stats || + opt_D_dump_rn + = getRnStats all_decls `thenRn` \ msg -> + ioToRnMG (printErrs msg) `thenRn_` + returnRn () + + | otherwise = returnRn () \end{code} -Why stop if errors in the first three passes: Suppose you're compiling -a module with a top-level definition named \tr{scaleFloat}. Sadly, -this is also a Prelude class-method name. \tr{rnModule3} will have -detected this error, but: it will also have picked (arbitrarily) one -of the two definitions for its final ``value'' name-function. If, by -chance, it should have picked the class-method... when it comes to pin -a Unique on the top-level (bogus) \tr{scaleFloat}, it will ask for the -class-method's Unique (!); it doesn't have one, and you will get a -panic. - -Another way to handle this would be for the duplicate detector to -clobber duplicates with some ``safe'' value. Then things would be -fine in \tr{rnModule}. Maybe some other time...