X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Frename%2FRnNames.lhs;h=bb164ea669e5664754f1a48e8ebbd464be22f69f;hb=69d9940e0c511b6c349744aa32a29dab4152b5a2;hp=26fadbe628356354b7fdceb91de0ae5b3de04f3d;hpb=f0be46023a60a192954ddbfb6b2e0e72d371c55f;p=ghc-hetmet.git diff --git a/compiler/rename/RnNames.lhs b/compiler/rename/RnNames.lhs index 26fadbe..bb164ea 100644 --- a/compiler/rename/RnNames.lhs +++ b/compiler/rename/RnNames.lhs @@ -4,18 +4,24 @@ \section[RnNames]{Extracting imported and top-level names in scope} \begin{code} +{-# OPTIONS -w #-} +-- The above warning supression flag is a temporary kludge. +-- While working on this module you are encouraged to remove it and fix +-- any warnings in the module. See +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings +-- for details + module RnNames ( - rnImports, importsFromLocalDecls, - rnExports, - getLocalDeclBinders, extendRdrEnvRn, - reportUnusedNames, finishDeprecations + rnImports, getLocalNonValBinders, + rnExports, extendGlobalRdrEnvRn, + reportUnusedNames, finishDeprecations, ) where #include "HsVersions.h" import DynFlags import HsSyn ( IE(..), ieName, ImportDecl(..), LImportDecl, - ForeignDecl(..), HsGroup(..), HsValBinds(..), + ForeignDecl(..), HsGroup(..), HsValBindsLR(..), Sig(..), collectHsBindLocatedBinders, tyClDeclNames, instDeclATs, isFamInstDecl, LIE ) @@ -29,6 +35,7 @@ import PrelNames import Module import Name import NameEnv +import LazyUniqFM import NameSet import OccName import HscTypes @@ -38,13 +45,14 @@ import Maybes import SrcLoc import FiniteMap import ErrUtils -import BasicTypes ( DeprecTxt ) +import BasicTypes ( DeprecTxt, Fixity ) import DriverPhases ( isHsBoot ) import Util +import FastString import ListSetOps import Data.List ( partition, concatMap, (\\), delete ) import IO ( openFile, IOMode(..) ) -import Monad ( when ) +import Monad ( when, mplus ) \end{code} @@ -57,7 +65,7 @@ import Monad ( when ) \begin{code} rnImports :: [LImportDecl RdrName] - -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails) + -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage) rnImports imports -- PROCESS IMPORT DECLS @@ -75,18 +83,19 @@ rnImports imports stuff1 <- mapM (rnImportDecl this_mod) (prel_imports ++ ordinary) stuff2 <- mapM (rnImportDecl this_mod) source - let (decls, rdr_env, imp_avails) = combine (stuff1 ++ stuff2) - return (decls, rdr_env, imp_avails) + let (decls, rdr_env, imp_avails,hpc_usage) = combine (stuff1 ++ stuff2) + return (decls, rdr_env, imp_avails,hpc_usage) where - combine :: [(LImportDecl Name, GlobalRdrEnv, ImportAvails)] - -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails) - combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails) - where plus (decl, gbl_env1, imp_avails1) - (decls, gbl_env2, imp_avails2) + combine :: [(LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)] + -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage) + combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails,False) + where plus (decl, gbl_env1, imp_avails1,hpc_usage1) + (decls, gbl_env2, imp_avails2,hpc_usage2) = (decl:decls, gbl_env1 `plusGlobalRdrEnv` gbl_env2, - imp_avails1 `plusImportAvails` imp_avails2) + imp_avails1 `plusImportAvails` imp_avails2, + hpc_usage1 || hpc_usage2) mkPrelImports :: Module -> Bool -> [LImportDecl RdrName] -> [LImportDecl RdrName] -- Consruct the implicit declaration "import Prelude" (or not) @@ -114,12 +123,12 @@ mkPrelImports this_mod implicit_prelude import_decls Nothing {- No "as" -} Nothing {- No import list -} - loc = mkGeneralSrcSpan FSLIT("Implicit import declaration") + loc = mkGeneralSrcSpan (fsLit "Implicit import declaration") rnImportDecl :: Module -> LImportDecl RdrName - -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails) + -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage) rnImportDecl this_mod (L loc (ImportDecl loc_imp_mod_name want_boot qual_only as_mod imp_details)) @@ -130,7 +139,7 @@ rnImportDecl this_mod (L loc (ImportDecl loc_imp_mod_name want_boot -- file not found) we get lots of spurious errors from 'filterImports' let imp_mod_name = unLoc loc_imp_mod_name - doc = ppr imp_mod_name <+> ptext SLIT("is directly imported") + doc = ppr imp_mod_name <+> ptext (sLit "is directly imported") iface <- loadSrcInterface doc imp_mod_name want_boot @@ -228,7 +237,7 @@ rnImportDecl this_mod (L loc (ImportDecl loc_imp_mod_name want_boot other -> False imports = ImportAvails { - imp_mods = unitModuleEnv imp_mod (imp_mod, import_all, loc), + imp_mods = unitModuleEnv imp_mod (imp_mod, [(qual_mod_name, import_all, loc)]), imp_orphs = orphans, imp_finsts = finsts, imp_dep_mods = mkModDeps dependent_mods, @@ -239,17 +248,17 @@ rnImportDecl this_mod (L loc (ImportDecl loc_imp_mod_name want_boot ifOptM Opt_WarnDeprecations ( case deprecs of DeprecAll txt -> addWarn (moduleDeprec imp_mod_name txt) - other -> returnM () + other -> return () ) let new_imp_decl = L loc (ImportDecl loc_imp_mod_name want_boot qual_only as_mod new_imp_details) - returnM (new_imp_decl, gbl_env, imports) + return (new_imp_decl, gbl_env, imports, mi_hpc iface) ) warnRedundantSourceImport mod_name - = ptext SLIT("Unnecessary {-# SOURCE #-} in the import of module") + = ptext (sLit "Unnecessary {-# SOURCE #-} in the import of module") <+> quotes (ppr mod_name) \end{code} @@ -265,36 +274,71 @@ From the top-level declarations of this module produce * the ImportAvails created by its bindings. -Complain about duplicate bindings +Note [Shadowing in extendGlobalRdrEnvRn] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Usually when etending the GlobalRdrEnv we complain if a new binding +duplicates an existing one. By adding the bindings one at a time, +this check also complains if we add two new bindings for the same name. +(Remember that in Template Haskell the duplicates might *already be* +in the GlobalRdrEnv from higher up the module.) + +But with a Template Haskell quotation we want to *shadow*: + f x = h [d| f = 3 |] +Here the inner binding for 'f' simply shadows the outer one. +And that applies even if the binding for 'f' is in a where-clause, +and hence is in the *local* RdrEnv not the *global* RdrEnv. + +Hence the shadowP boolean passed in. \begin{code} -importsFromLocalDecls :: HsGroup RdrName -> RnM TcGblEnv -importsFromLocalDecls group - = do { gbl_env <- getGblEnv - - ; avails <- getLocalDeclBinders gbl_env group - - ; rdr_env' <- extendRdrEnvRn (tcg_rdr_env gbl_env) avails +extendGlobalRdrEnvRn :: Bool -- Note [Shadowing in extendGlobalRdrEnvRn] + -> [AvailInfo] + -> MiniFixityEnv + -> RnM (TcGblEnv, TcLclEnv) + -- Updates both the GlobalRdrEnv and the FixityEnv + -- We return a new TcLclEnv only becuase we might have to + -- delete some bindings from it; see Note [Shadowing in extendGlobalRdrEnvRn] + +extendGlobalRdrEnvRn shadowP avails new_fixities + = do { (gbl_env, lcl_env) <- getEnvs + ; let rdr_env = tcg_rdr_env gbl_env + fix_env = tcg_fix_env gbl_env + + -- Delete new_occs from global and local envs + -- We are going to shadow them + -- See Note [Shadowing in extendGlobalRdrEnvRn] + new_occs = map (nameOccName . gre_name) gres + rdr_env1 = hideSomeUnquals rdr_env new_occs + lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs } + + -- Note [Shadowing in extendGlobalRdrEnvRn] + (rdr_env2, lcl_env2) | shadowP = (rdr_env1, lcl_env1) + | otherwise = (rdr_env, lcl_env) - ; traceRn (text "local avails: " <> ppr avails) + ; (rdr_env', fix_env') <- foldlM extend (rdr_env2, fix_env) gres + + ; let gbl_env' = gbl_env { tcg_rdr_env = rdr_env', tcg_fix_env = fix_env' } + ; traceRn (text "extendGlobalRdrEnvRn" <+> (ppr new_fixities $$ ppr fix_env $$ ppr fix_env')) + ; return (gbl_env', lcl_env2) } + where + gres = gresFromAvails LocalDef avails - ; returnM (gbl_env { tcg_rdr_env = rdr_env' }) - } + extend envs@(cur_rdr_env, cur_fix_env) gre + = let gres = lookupGlobalRdrEnv cur_rdr_env (nameOccName (gre_name gre)) + in case filter isLocalGRE gres of -- Check for existing *local* defns + dup_gre:_ -> do { addDupDeclErr (gre_name dup_gre) (gre_name gre) + ; return envs } + [] -> return (simple_extend envs gre) -extendRdrEnvRn :: GlobalRdrEnv -> [AvailInfo] -> RnM GlobalRdrEnv --- Add the new locally-bound names one by one, checking for duplicates as --- we do so. Remember that in Template Haskell the duplicates --- might *already be* in the GlobalRdrEnv from higher up the module -extendRdrEnvRn rdr_env avails - = foldlM add_local rdr_env (gresFromAvails LocalDef avails) - where - add_local rdr_env gre - | gres <- lookupGlobalRdrEnv rdr_env (nameOccName (gre_name gre)) - , (dup_gre:_) <- filter isLocalGRE gres -- Check for existing *local* defns - = do { addDupDeclErr (gre_name dup_gre) (gre_name gre) - ; return rdr_env } - | otherwise - = return (extendGlobalRdrEnv rdr_env gre) + simple_extend (rdr_env, fix_env) gre + = (extendGlobalRdrEnv rdr_env gre, fix_env') + where + -- If there is a fixity decl for the gre, add it to the fixity env + name = gre_name gre + occ = nameOccName name + fix_env' = case lookupFsEnv new_fixities (occNameFS occ) of + Nothing -> fix_env + Just (L _ fi) -> extendNameEnv fix_env name (FixItem occ fi) \end{code} @getLocalDeclBinders@ returns the names for an @HsDecl@. It's @@ -314,46 +358,58 @@ raising a duplicate declaration error. So, we make a new name for it, but don't return it in the 'AvailInfo'. \begin{code} -getLocalDeclBinders :: TcGblEnv -> HsGroup RdrName -> RnM [AvailInfo] -getLocalDeclBinders gbl_env (HsGroup {hs_valds = ValBindsIn val_decls val_sigs, - hs_tyclds = tycl_decls, - hs_instds = inst_decls, - hs_fords = foreign_decls }) - = do { tc_names_s <- mappM new_tc tycl_decls - ; at_names_s <- mappM inst_ats inst_decls - ; val_names <- mappM new_simple val_bndrs +getLocalNonValBinders :: HsGroup RdrName -> RnM [AvailInfo] +-- Get all the top-level binders bound the group *except* +-- for value bindings, which are treated separately +-- Specificaly we return AvailInfo for +-- type decls +-- class decls +-- associated types +-- foreign imports +-- (in hs-boot files) value signatures + +getLocalNonValBinders group + = do { gbl_env <- getGblEnv + ; get_local_binders gbl_env group } + +get_local_binders gbl_env (HsGroup {hs_valds = ValBindsIn _ val_sigs, + hs_tyclds = tycl_decls, + hs_instds = inst_decls, + hs_fords = foreign_decls }) + = do { tc_names_s <- mapM new_tc tycl_decls + ; at_names_s <- mapM inst_ats inst_decls + ; val_names <- mapM new_simple val_bndrs ; return (val_names ++ tc_names_s ++ concat at_names_s) } where mod = tcg_mod gbl_env is_hs_boot = isHsBoot (tcg_src gbl_env) ; - val_bndrs | is_hs_boot = sig_hs_bndrs - | otherwise = for_hs_bndrs ++ val_hs_bndrs - -- In a hs-boot file, the value binders come from the - -- *signatures*, and there should be no foreign binders + + for_hs_bndrs = [nm | L _ (ForeignImport nm _ _) <- foreign_decls] + + -- In a hs-boot file, the value binders come from the + -- *signatures*, and there should be no foreign binders + val_bndrs | is_hs_boot = [nm | L _ (TypeSig nm _) <- val_sigs] + | otherwise = for_hs_bndrs new_simple rdr_name = do nm <- newTopSrcBinder mod rdr_name return (Avail nm) - sig_hs_bndrs = [nm | L _ (TypeSig nm _) <- val_sigs] - val_hs_bndrs = collectHsBindLocatedBinders val_decls - for_hs_bndrs = [nm | L _ (ForeignImport nm _ _) <- foreign_decls] - new_tc tc_decl | isFamInstDecl (unLoc tc_decl) = do { main_name <- lookupFamInstDeclBndr mod main_rdr - ; sub_names <- mappM (newTopSrcBinder mod) sub_rdrs + ; sub_names <- mapM (newTopSrcBinder mod) sub_rdrs ; return (AvailTC main_name sub_names) } -- main_name is not bound here! | otherwise = do { main_name <- newTopSrcBinder mod main_rdr - ; sub_names <- mappM (newTopSrcBinder mod) sub_rdrs + ; sub_names <- mapM (newTopSrcBinder mod) sub_rdrs ; return (AvailTC main_name (main_name : sub_names)) } where (main_rdr : sub_rdrs) = tyClDeclNames (unLoc tc_decl) inst_ats inst_decl - = mappM new_tc (instDeclATs (unLoc inst_decl)) + = mapM new_tc (instDeclATs (unLoc inst_decl)) getLocalDeclBinders _ _ = panic "getLocalDeclBinders" -- ValBindsOut can't happen \end{code} @@ -758,6 +814,10 @@ exports_from_avail (Just rdr_items) rdr_env imports this_mod kids_env :: NameEnv [Name] -- Maps a parent to its in-scope children kids_env = mkChildEnv (globalRdrEnvElts rdr_env) + imported_modules = [ qual_name + | (_, xs) <- moduleEnvElts $ imp_mods imports, + (qual_name, _, _) <- xs ] + exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum exports_from_item acc@(ie_names, occs, exports) (L loc ie@(IEModuleContents mod)) @@ -765,14 +825,18 @@ exports_from_avail (Just rdr_items) rdr_env imports this_mod , mod `elem` earlier_mods -- Duplicate export of M = do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ; warnIf warn_dup_exports (dupModuleExport mod) ; - returnM acc } + return acc } | otherwise = do { implicit_prelude <- doptM Opt_ImplicitPrelude - ; let gres = filter (isModuleExported implicit_prelude mod) - (globalRdrEnvElts rdr_env) + ; let { exportValid = (mod `elem` imported_modules) + || (moduleName this_mod == mod) + ; gres = filter (isModuleExported implicit_prelude mod) + (globalRdrEnvElts rdr_env) + } - ; warnIf (null gres) (nullModuleExport mod) + ; checkErr exportValid (moduleNotImported mod) + ; warnIf (exportValid && null gres) (nullModuleExport mod) ; occs' <- check_occs ie occs (map gre_name gres) -- This check_occs not only finds conflicts @@ -888,18 +952,18 @@ check_occs ie occs names where check occs name = case lookupOccEnv occs name_occ of - Nothing -> returnM (extendOccEnv occs name_occ (name, ie)) + Nothing -> return (extendOccEnv occs name_occ (name, ie)) Just (name', ie') | name == name' -- Duplicate export -> do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ; warnIf warn_dup_exports (dupExportWarn name_occ ie ie') ; - returnM occs } + return occs } | otherwise -- Same occ name but different names: an error -> do { global_env <- getGlobalRdrEnv ; addErr (exportClashErr global_env name' name ie' ie) ; - returnM occs } + return occs } where name_occ = nameOccName name \end{code} @@ -937,7 +1001,7 @@ finishDeprecations dflags mod_deprec tcg_env | name `elemNameSet` used_names , Just deprec_txt <- lookupImpDeprec dflags hpt pit gre = addWarnAt (importSpecLoc imp_spec) - (sep [ptext SLIT("Deprecated use of") <+> + (sep [ptext (sLit "Deprecated use of") <+> pprNonVarNameSpace (occNameSpace (nameOccName name)) <+> quotes (ppr name), (parens imp_msg) <> colon, @@ -945,11 +1009,11 @@ finishDeprecations dflags mod_deprec tcg_env where name_mod = nameModule name imp_mod = importSpecModule imp_spec - imp_msg = ptext SLIT("imported from") <+> ppr imp_mod <> extra + imp_msg = ptext (sLit "imported from") <+> ppr imp_mod <> extra extra | imp_mod == moduleName name_mod = empty - | otherwise = ptext SLIT(", but defined in") <+> ppr name_mod + | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod - check hpt pit ok_gre = returnM () -- Local, or not used, or not deprectated + check hpt pit ok_gre = return () -- Local, or not used, or not deprectated -- The Imported pattern-match: don't deprecate locally defined names -- For a start, we may be exporting a deprecated thing -- Also we may use a deprecated thing in the defn of another @@ -962,7 +1026,7 @@ lookupImpDeprec :: DynFlags -> HomePackageTable -> PackageIfaceTable -- The name is definitely imported, so look in HPT, PIT lookupImpDeprec dflags hpt pit gre = case lookupIfaceByModule dflags hpt pit (nameModule name) of - Just iface -> mi_dep_fn iface name `seqMaybe` -- Bleat if the thing, *or + Just iface -> mi_dep_fn iface name `mplus` -- Bleat if the thing, *or case gre_par gre of ParentIs p -> mi_dep_fn iface p -- its parent*, is deprec'd NoParent -> Nothing @@ -1109,7 +1173,7 @@ reportUnusedNames export_decls gbl_env -- qualified imports into account. But it's an improvement. add_expall mod acc = addToFM_C plusAvailEnv acc mod emptyAvailEnv - add_inst_mod (mod,_,_) acc + add_inst_mod (mod, _) acc | mod_name `elemFM` acc = acc -- We import something already | otherwise = addToFM acc mod_name emptyAvailEnv where @@ -1119,7 +1183,7 @@ reportUnusedNames export_decls gbl_env imports = tcg_imports gbl_env - direct_import_mods :: [(Module, Bool, SrcSpan)] + direct_import_mods :: [(Module, [(ModuleName, Bool, SrcSpan)])] -- See the type of the imp_mods for this triple direct_import_mods = moduleEnvElts (imp_mods imports) @@ -1128,10 +1192,11 @@ reportUnusedNames export_decls gbl_env -- [Note: not 'minimal_imports', because that includes directly-imported -- modules even if we use nothing from them; see notes above] -- - -- BUG WARNING: does not deal correctly with multiple imports of the same module - -- becuase direct_import_mods has only one entry per module + -- BUG WARNING: this code is generally buggy unused_imp_mods :: [(ModuleName, SrcSpan)] - unused_imp_mods = [(mod_name,loc) | (mod,no_imp,loc) <- direct_import_mods, + unused_imp_mods = [(mod_name,loc) + | (mod, xs) <- direct_import_mods, + (_, no_imp, loc) <- xs, let mod_name = moduleName mod, not (mod_name `elemFM` minimal_imports1), mod /= pRELUDE, @@ -1166,14 +1231,14 @@ warnDuplicateImports :: [GlobalRdrElt] -> RnM () warnDuplicateImports gres = ifOptM Opt_WarnUnusedImports $ - sequenceM_ [ warn name pr + sequence_ [ warn name pr | GRE { gre_name = name, gre_prov = Imported imps } <- gres , pr <- redundants imps ] where warn name (red_imp, cov_imp) = addWarnAt (importSpecLoc red_imp) - (vcat [ptext SLIT("Redundant import of:") <+> quotes pp_name, - ptext SLIT("It is also") <+> ppr cov_imp]) + (vcat [ptext (sLit "Redundant import of:") <+> quotes pp_name, + ptext (sLit "It is also") <+> ppr cov_imp]) where pp_name | is_qual red_decl = ppr (is_as red_decl) <> dot <> ppr occ | otherwise = ppr occ @@ -1198,7 +1263,7 @@ warnDuplicateImports gres -- -- NOTE: currently the test does not warn about -- import M( x ) - -- imoprt N( x ) + -- import N( x ) -- even if the same underlying 'x' is involved, because dropping -- either import would change the qualified names in scope (M.x, N.x) -- But if the qualified names aren't used, the import is indeed redundant @@ -1234,12 +1299,13 @@ printMinimalImports :: FiniteMap ModuleName AvailEnv -- Minimal imports printMinimalImports imps = ifOptM Opt_D_dump_minimal_imports $ do { - mod_ies <- initIfaceTcRn $ mappM to_ies (fmToList imps) ; + mod_ies <- initIfaceTcRn $ mapM to_ies (fmToList imps) ; this_mod <- getModule ; rdr_env <- getGlobalRdrEnv ; - ioToTcRn (do { h <- openFile (mkFilename this_mod) WriteMode ; - printForUser h (mkPrintUnqualified rdr_env) - (vcat (map ppr_mod_ie mod_ies)) }) + dflags <- getDOpts ; + liftIO $ do h <- openFile (mkFilename this_mod) WriteMode + printForUser h (mkPrintUnqualified dflags rdr_env) + (vcat (map ppr_mod_ie mod_ies)) } where mkFilename this_mod = moduleNameString (moduleName this_mod) ++ ".imports" @@ -1247,31 +1313,31 @@ printMinimalImports imps | mod_name == moduleName pRELUDE = empty | null ies -- Nothing except instances comes from here - = ptext SLIT("import") <+> ppr mod_name <> ptext SLIT("() -- Instances only") + = ptext (sLit "import") <+> ppr mod_name <> ptext (sLit "() -- Instances only") | otherwise - = ptext SLIT("import") <+> ppr mod_name <> + = ptext (sLit "import") <+> ppr mod_name <> parens (fsep (punctuate comma (map ppr ies))) to_ies (mod, avail_env) = do ies <- mapM to_ie (availEnvElts avail_env) - returnM (mod, ies) + return (mod, ies) to_ie :: AvailInfo -> IfG (IE Name) -- The main trick here is that if we're importing all the constructors -- we want to say "T(..)", but if we're importing only a subset we want -- to say "T(A,B,C)". So we have to find out what the module exports. - to_ie (Avail n) = returnM (IEVar n) + to_ie (Avail n) = return (IEVar n) to_ie (AvailTC n [m]) = ASSERT( n==m ) - returnM (IEThingAbs n) - to_ie (AvailTC n ns) - = loadSysInterface doc n_mod `thenM` \ iface -> + return (IEThingAbs n) + to_ie (AvailTC n ns) = do + iface <- loadSysInterface doc n_mod case [xs | (m,as) <- mi_exports iface, m == n_mod, AvailTC x xs <- as, x == nameOccName n] of - [xs] | all_used xs -> returnM (IEThingAll n) - | otherwise -> returnM (IEThingWith n (filter (/= n) ns)) + [xs] | all_used xs -> return (IEThingAll n) + | otherwise -> return (IEThingWith n (filter (/= n) ns)) other -> pprTrace "to_ie" (ppr n <+> ppr n_mod <+> ppr other) $ - returnM (IEVar n) + return (IEVar n) where all_used avail_occs = all (`elem` map nameOccName ns) avail_occs doc = text "Compute minimal imports from" <+> ppr n @@ -1287,39 +1353,39 @@ printMinimalImports imps \begin{code} badImportItemErr iface decl_spec ie - = sep [ptext SLIT("Module"), quotes (ppr (is_mod decl_spec)), source_import, - ptext SLIT("does not export"), quotes (ppr ie)] + = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import, + ptext (sLit "does not export"), quotes (ppr ie)] where - source_import | mi_boot iface = ptext SLIT("(hi-boot interface)") + source_import | mi_boot iface = ptext (sLit "(hi-boot interface)") | otherwise = empty -illegalImportItemErr = ptext SLIT("Illegal import item") +illegalImportItemErr = ptext (sLit "Illegal import item") -dodgyImportWarn item = dodgyMsg (ptext SLIT("import")) item -dodgyExportWarn item = dodgyMsg (ptext SLIT("export")) item +dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item +dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item dodgyMsg kind tc - = sep [ ptext SLIT("The") <+> kind <+> ptext SLIT("item") <+> quotes (ppr (IEThingAll tc)), - ptext SLIT("suggests that") <+> quotes (ppr tc) <+> ptext SLIT("has constructors or class methods,"), - ptext SLIT("but it has none") ] + = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc)), + ptext (sLit "suggests that") <+> quotes (ppr tc) <+> ptext (sLit "has constructors or class methods,"), + ptext (sLit "but it has none") ] exportItemErr export_item - = sep [ ptext SLIT("The export item") <+> quotes (ppr export_item), - ptext SLIT("attempts to export constructors or class methods that are not visible here") ] + = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item), + ptext (sLit "attempts to export constructors or class methods that are not visible here") ] typeItemErr name wherestr - = sep [ ptext SLIT("Using 'type' tag on") <+> quotes (ppr name) <+> wherestr, - ptext SLIT("Use -ftype-families to enable this extension") ] + = sep [ ptext (sLit "Using 'type' tag on") <+> quotes (ppr name) <+> wherestr, + ptext (sLit "Use -XTypeFamilies to enable this extension") ] exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName -> Message exportClashErr global_env name1 name2 ie1 ie2 - = vcat [ ptext SLIT("Conflicting exports for") <+> quotes (ppr occ) <> colon + = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon , ppr_export ie1' name1' , ppr_export ie2' name2' ] where occ = nameOccName name1 - ppr_export ie name = nest 2 (quotes (ppr ie) <+> ptext SLIT("exports") <+> + ppr_export ie name = nest 2 (quotes (ppr ie) <+> ptext (sLit "exports") <+> quotes (ppr name) <+> pprNameProvenance (get_gre name)) -- get_gre finds a GRE for the Name, so that we can show its provenance @@ -1335,8 +1401,8 @@ exportClashErr global_env name1 name2 ie1 ie2 addDupDeclErr :: Name -> Name -> TcRn () addDupDeclErr name_a name_b = addErrAt (srcLocSpan loc2) $ - vcat [ptext SLIT("Multiple declarations of") <+> quotes (ppr name1), - ptext SLIT("Declared at:") <+> vcat [ppr (nameSrcLoc name1), ppr loc2]] + vcat [ptext (sLit "Multiple declarations of") <+> quotes (ppr name1), + ptext (sLit "Declared at:") <+> vcat [ppr (nameSrcLoc name1), ppr loc2]] where loc2 = nameSrcLoc name2 (name1,name2) | nameSrcLoc name_a > nameSrcLoc name_b = (name_b,name_a) @@ -1345,21 +1411,26 @@ addDupDeclErr name_a name_b dupExportWarn occ_name ie1 ie2 = hsep [quotes (ppr occ_name), - ptext SLIT("is exported by"), quotes (ppr ie1), - ptext SLIT("and"), quotes (ppr ie2)] + ptext (sLit "is exported by"), quotes (ppr ie1), + ptext (sLit "and"), quotes (ppr ie2)] dupModuleExport mod - = hsep [ptext SLIT("Duplicate"), - quotes (ptext SLIT("Module") <+> ppr mod), - ptext SLIT("in export list")] + = hsep [ptext (sLit "Duplicate"), + quotes (ptext (sLit "Module") <+> ppr mod), + ptext (sLit "in export list")] + +moduleNotImported :: ModuleName -> SDoc +moduleNotImported mod + = ptext (sLit "The export item `module") <+> ppr mod <> + ptext (sLit "' is not imported") nullModuleExport mod - = ptext SLIT("The export item `module") <+> ppr mod <> ptext SLIT("' exports nothing") + = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing") moduleDeprec mod txt - = sep [ ptext SLIT("Module") <+> quotes (ppr mod) <+> ptext SLIT("is deprecated:"), + = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <+> ptext (sLit "is deprecated:"), nest 4 (ppr txt) ] implicitPreludeWarn - = ptext SLIT("Module `Prelude' implicitly imported") + = ptext (sLit "Module `Prelude' implicitly imported") \end{code}