X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FRnEnv.lhs;h=9a7e56d9875f59d14387bd76543d147086b7c17d;hb=5a763550bf31ce446812d89f4967b601f122d344;hp=a87d73c52cedc09cd8c4665cc79d1c45adfec9c9;hpb=16873c648965fb122d9525823f86662bfc3f3d77;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/RnEnv.lhs b/ghc/compiler/rename/RnEnv.lhs index a87d73c..9a7e56d 100644 --- a/ghc/compiler/rename/RnEnv.lhs +++ b/ghc/compiler/rename/RnEnv.lhs @@ -8,46 +8,38 @@ module RnEnv where -- Export everything #include "HsVersions.h" -import CmdLineOpts ( opt_WarnNameShadowing, opt_WarnUnusedMatches, - opt_WarnUnusedBinds, opt_WarnUnusedImports ) import HsSyn import RdrHsSyn ( RdrNameIE ) -import RnHsSyn ( RenamedHsType ) -import RdrName ( RdrName, rdrNameModule, rdrNameOcc, isQual, isUnqual, - mkRdrUnqual, qualifyRdrName +import RdrName ( RdrName, rdrNameModule, rdrNameOcc, isQual, isUnqual, isOrig, + mkRdrUnqual, mkRdrQual, qualifyRdrName, lookupRdrEnv, foldRdrEnv ) -import HsTypes ( getTyVarName, replaceTyVarName ) - +import HsTypes ( hsTyVarName, replaceTyVarName ) +import HscTypes ( Provenance(..), pprNameProvenance, hasBetterProv, + ImportReason(..), GlobalRdrEnv, AvailEnv, + AvailInfo, Avails, GenAvailInfo(..), NameSupply(..) ) import RnMonad -import Name ( Name, Provenance(..), ExportFlag(..), NamedThing(..), - ImportReason(..), getSrcLoc, - mkLocalName, mkImportedLocalName, mkGlobalName, mkUnboundName, - mkIPName, isSystemName, isWiredInName, - nameOccName, setNameModule, nameModule, - pprOccName, isLocallyDefined, nameUnique, nameOccName, - occNameUserString, - setNameProvenance, getNameProvenance, pprNameProvenance +import Name ( Name, NamedThing(..), + getSrcLoc, + mkLocalName, mkGlobalName, + mkIPName, nameOccName, nameModule_maybe, + setNameModuleAndLoc ) +import Name ( extendNameEnv_C, plusNameEnv_C, nameEnvElts ) import NameSet -import OccName ( OccName, - mkDFunOcc, occNameUserString, occNameString, - occNameFlavour - ) -import TysWiredIn ( tupleTyCon, unboxedTupleTyCon, listTyCon ) -import Type ( funTyCon ) -import Module ( ModuleName, mkThisModule, moduleName, mkVanillaModule, pprModuleName ) -import TyCon ( TyCon ) +import OccName ( OccName, occNameUserString, occNameFlavour ) +import Module ( ModuleName, moduleName, mkVanillaModule, mkSysModuleNameFS, moduleNameFS ) import FiniteMap -import Unique ( Unique, Uniquable(..) ) import UniqSupply import SrcLoc ( SrcLoc, noSrcLoc ) import Outputable -import Util ( removeDups, equivClasses, thenCmp ) +import ListSetOps ( removeDups, equivClasses ) +import Util ( sortLt ) import List ( nub ) +import PrelNames ( mkUnboundName ) +import CmdLineOpts +import FastString ( FastString ) \end{code} - - %********************************************************* %* * \subsection{Making new names} @@ -55,72 +47,73 @@ import List ( nub ) %********************************************************* \begin{code} -newLocalTopBinder :: Module -> OccName - -> (Name -> ExportFlag) -> SrcLoc - -> RnM d Name -newLocalTopBinder mod occ rec_exp_fn loc - = newTopBinder mod occ (\name -> setNameProvenance name (LocalDef loc (rec_exp_fn name))) - -- We must set the provenance of the thing in the cache - -- correctly, particularly whether or not it is locally defined. - -- - -- Since newLocalTopBinder is used only - -- at binding occurrences, we may as well get the provenance - -- dead right first time; hence the rec_exp_fn passed in - -newImportedBinder :: Module -> RdrName -> RnM d Name -newImportedBinder mod rdr_name - = ASSERT2( isUnqual rdr_name, ppr rdr_name ) - newTopBinder mod (rdrNameOcc rdr_name) (\name -> name) - -- Provenance is already implicitImportProvenance - -implicitImportProvenance = NonLocalDef ImplicitImport False - -newTopBinder :: Module -> OccName -> (Name -> Name) -> RnM d Name -newTopBinder mod occ set_prov +newTopBinder :: Module -> RdrName -> SrcLoc -> RnM d Name + -- newTopBinder puts into the cache the binder with the + -- module information set correctly. When the decl is later renamed, + -- the binding site will thereby get the correct module. + -- There maybe occurrences that don't have the correct Module, but + -- by the typechecker will propagate the binding definition to all + -- the occurrences, so that doesn't matter + +newTopBinder mod rdr_name loc = -- First check the cache - getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> + -- traceRn (text "newTopBinder" <+> ppr mod <+> ppr loc) `thenRn_` + + -- There should never be a qualified name in a binding position (except in instance decls) + -- The parser doesn't check this because the same parser parses instance decls + (if isQual rdr_name then + qualNameErr (text "its declaration") (rdr_name,loc) + else + returnRn () + ) `thenRn_` + + getNameSupplyRn `thenRn` \ name_supply -> let - key = (moduleName mod, occ) + occ = rdrNameOcc rdr_name + key = (moduleName mod, occ) + cache = nsNames name_supply in case lookupFM cache key of - -- A hit in the cache! - -- Set the Module of the thing, and set its provenance (hack pending - -- spj update) - -- - -- It also means that if there are two defns for the same thing - -- in a module, then each gets a separate SrcLoc - -- - -- There's a complication for wired-in names. We don't want to - -- forget that they are wired in even when compiling that module - -- (else we spit out redundant defns into the interface file) - -- So for them we just set the provenance + -- A hit in the cache! We are at the binding site of the name, and + -- this is the moment when we know all about + -- a) the Name's host Module (in particular, which + -- package it comes from) + -- b) its defining SrcLoc + -- So we update this info Just name -> let - new_name = set_prov (setNameModule name mod) + new_name = setNameModuleAndLoc name mod loc new_cache = addToFM cache key new_name in - setNameSupplyRn (us, inst_ns, new_cache, ipcache) `thenRn_` + setNameSupplyRn (name_supply {nsNames = new_cache}) `thenRn_` + traceRn (text "newTopBinder: overwrite" <+> ppr new_name) `thenRn_` returnRn new_name -- Miss in the cache! -- Build a completely new Name, and put it in the cache + -- Even for locally-defined names we use implicitImportProvenance; + -- updateProvenances will set it to rights Nothing -> let - (us', us1) = splitUniqSupply us + (us', us1) = splitUniqSupply (nsUniqs name_supply) uniq = uniqFromSupply us1 - new_name = set_prov (mkGlobalName uniq mod occ implicitImportProvenance) + new_name = mkGlobalName uniq mod occ loc new_cache = addToFM cache key new_name in - setNameSupplyRn (us', inst_ns, new_cache, ipcache) `thenRn_` + setNameSupplyRn (name_supply {nsUniqs = us', nsNames = new_cache}) `thenRn_` + traceRn (text "newTopBinder: new" <+> ppr new_name) `thenRn_` returnRn new_name -mkImportedGlobalName :: ModuleName -> OccName -> RnM d Name +newGlobalName :: ModuleName -> OccName -> RnM d Name -- Used for *occurrences*. We make a place-holder Name, really just -- to agree on its unique, which gets overwritten when we read in - -- the binding occurence later (newImportedBinder) - -- The place-holder Name doesn't have the right Provenance, and its - -- Module won't have the right Package either + -- the binding occurence later (newTopBinder) + -- The place-holder Name doesn't have the right SrcLoc, and its + -- Module won't have the right Package either. + -- + -- (We have to pass a ModuleName, not a Module, because we may be + -- simply looking at an occurrence M.x in an interface file.) -- -- This means that a renamed program may have incorrect info -- on implicitly-imported occurrences, but the correct info on the @@ -130,73 +123,37 @@ mkImportedGlobalName :: ModuleName -> OccName -> RnM d Name -- it doesn't matter that we get the correct info in place till later, -- (but since it affects DLL-ery it does matter that we get it right -- in the end). -mkImportedGlobalName mod_name occ - = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> +newGlobalName mod_name occ + = getNameSupplyRn `thenRn` \ name_supply -> let key = (mod_name, occ) + cache = nsNames name_supply in case lookupFM cache key of - Just name -> returnRn name - Nothing -> setNameSupplyRn (us', inst_ns, new_cache, ipcache) `thenRn_` + Just name -> -- traceRn (text "newGlobalName: hit" <+> ppr name) `thenRn_` + returnRn name + + Nothing -> setNameSupplyRn (name_supply {nsUniqs = us', nsNames = new_cache}) `thenRn_` + -- traceRn (text "newGlobalName: new" <+> ppr name) `thenRn_` returnRn name where - (us', us1) = splitUniqSupply us + (us', us1) = splitUniqSupply (nsUniqs name_supply) uniq = uniqFromSupply us1 mod = mkVanillaModule mod_name - name = mkGlobalName uniq mod occ implicitImportProvenance + name = mkGlobalName uniq mod occ noSrcLoc new_cache = addToFM cache key name -updateProvenances :: [Name] -> RnM d () --- Update the provenances of everything that is in scope. --- We must be careful not to disturb the Module package info --- already in the cache. Why not? Consider --- module A module M( f ) --- import M( f ) import N( f) --- import N --- So f is defined in N, and M re-exports it. --- When processing module A: --- 1. We read M.hi first, and make a vanilla name N.f --- (without reading N.hi). The package info says --- for lack of anything better. --- 2. Now we read N, which update the cache to record --- the correct package for N.f. --- 3. Finally we update provenances (once we've read all imports). --- Step 3 must not destroy package info recorded in Step 2. - -updateProvenances names - = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> - setNameSupplyRn (us, inst_ns, foldr update cache names, ipcache) - where - update name cache = addToFM_C update_prov cache key name - where - key = (moduleName (nameModule name), nameOccName name) - - update_prov name_in_cache name_with_prov - = setNameProvenance name_in_cache (getNameProvenance name_with_prov) - - - -mkImportedGlobalFromRdrName :: RdrName -> RnM d Name -mkImportedGlobalFromRdrName rdr_name - | isQual rdr_name - = mkImportedGlobalName (rdrNameModule rdr_name) (rdrNameOcc rdr_name) - - | otherwise - = -- An Unqual is allowed; interface files contain - -- unqualified names for locally-defined things, such as - -- constructors of a data type. - getModuleRn `thenRn ` \ mod_name -> - mkImportedGlobalName mod_name (rdrNameOcc rdr_name) - - -getIPName rdr_name - = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> +newIPName rdr_name + = getNameSupplyRn `thenRn` \ name_supply -> + let + ipcache = nsIPs name_supply + in case lookupFM ipcache key of Just name -> returnRn name - Nothing -> setNameSupplyRn (us', inst_ns, cache, new_ipcache) `thenRn_` + Nothing -> setNameSupplyRn (name_supply {nsUniqs = us', nsIPs = new_ipcache}) `thenRn_` returnRn name where - (us', us1) = splitUniqSupply us + (us', us1) = splitUniqSupply (nsUniqs name_supply) uniq = uniqFromSupply us1 name = mkIPName uniq key new_ipcache = addToFM ipcache key name @@ -205,46 +162,137 @@ getIPName rdr_name %********************************************************* %* * -\subsection{Dfuns and default methods} +\subsection{Looking up names} %* * %********************************************************* -@newImplicitBinder@ is used for (a) dfuns -(b) default methods, defined in this module. +Looking up a name in the RnEnv. \begin{code} -newImplicitBinder occ src_loc - = getModuleRn `thenRn` \ mod_name -> - newLocalTopBinder (mkThisModule mod_name) occ (\_ -> Exported) src_loc +lookupBndrRn rdr_name + = getLocalNameEnv `thenRn` \ local_env -> + case lookupRdrEnv local_env rdr_name of + Just name -> returnRn name + Nothing -> lookupTopBndrRn rdr_name + +lookupTopBndrRn rdr_name + = getModeRn `thenRn` \ mode -> + case mode of + InterfaceMode -> lookupIfaceName rdr_name + + SourceMode -> -- Source mode, so look up a *qualified* version + -- of the name, so that we get the right one even + -- if there are many with the same occ name + -- There must *be* a binding + getModuleRn `thenRn` \ mod -> + getGlobalNameEnv `thenRn` \ global_env -> + lookupSrcName global_env (qualifyRdrName (moduleName mod) rdr_name) + +-- lookupSigOccRn is used for type signatures and pragmas +-- Is this valid? +-- module A +-- import M( f ) +-- f :: Int -> Int +-- f x = x +-- It's clear that the 'f' in the signature must refer to A.f +-- The Haskell98 report does not stipulate this, but it will! +-- So we must treat the 'f' in the signature in the same way +-- as the binding occurrence of 'f', using lookupBndrRn +lookupSigOccRn :: RdrName -> RnMS Name +lookupSigOccRn = lookupBndrRn + +-- lookupOccRn looks up an occurrence of a RdrName +lookupOccRn :: RdrName -> RnMS Name +lookupOccRn rdr_name + = getLocalNameEnv `thenRn` \ local_env -> + case lookupRdrEnv local_env rdr_name of + Just name -> returnRn name + Nothing -> lookupGlobalOccRn rdr_name + +-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global +-- environment. It's used only for +-- record field names +-- class op names in class and instance decls + +lookupGlobalOccRn rdr_name + = getModeRn `thenRn` \ mode -> + case mode of + SourceMode -> getGlobalNameEnv `thenRn` \ global_env -> + lookupSrcName global_env rdr_name + + InterfaceMode -> lookupIfaceName rdr_name + +lookupSrcName :: GlobalRdrEnv -> RdrName -> RnM d Name +-- NB: passed GlobalEnv explicitly, not necessarily in RnMS monad +lookupSrcName global_env rdr_name + | isOrig rdr_name -- Can occur in source code too + = lookupOrigName rdr_name + + | otherwise + = case lookupRdrEnv global_env rdr_name of + Just [(name,_)] -> returnRn name + Just stuff@((name,_):_) -> addNameClashErrRn rdr_name stuff `thenRn_` + returnRn name + Nothing -> failWithRn (mkUnboundName rdr_name) + (unknownNameErr rdr_name) + +lookupOrigName :: RdrName -> RnM d Name +lookupOrigName rdr_name + = ASSERT( isOrig rdr_name ) + newGlobalName (rdrNameModule rdr_name) (rdrNameOcc rdr_name) + +lookupIfaceUnqual :: RdrName -> RnM d Name +lookupIfaceUnqual rdr_name + = ASSERT( isUnqual rdr_name ) + -- An Unqual is allowed; interface files contain + -- unqualified names for locally-defined things, such as + -- constructors of a data type. + getModuleRn `thenRn ` \ mod -> + newGlobalName (moduleName mod) (rdrNameOcc rdr_name) + +lookupIfaceName :: RdrName -> RnM d Name +lookupIfaceName rdr_name + | isUnqual rdr_name = lookupIfaceUnqual rdr_name + | otherwise = lookupOrigName rdr_name \end{code} -Make a name for the dict fun for an instance decl +@lookupOrigName@ takes an RdrName representing an {\em original} +name, and adds it to the occurrence pool so that it'll be loaded +later. This is used when language constructs (such as monad +comprehensions, overloaded literals, or deriving clauses) require some +stuff to be loaded that isn't explicitly mentioned in the code. + +This doesn't apply in interface mode, where everything is explicit, +but we don't check for this case: it does no harm to record an +``extra'' occurrence and @lookupOrigNames@ isn't used much in +interface mode (it's only the @Nothing@ clause of @rnDerivs@ that +calls it at all I think). + + \fbox{{\em Jan 98: this comment is wrong: @rnHsType@ uses it quite a bit.}} + \begin{code} -newDFunName :: (OccName, OccName) -> SrcLoc -> RnMS Name -newDFunName key@(cl_occ, tycon_occ) loc - = newInstUniq string `thenRn` \ inst_uniq -> - newImplicitBinder (mkDFunOcc string inst_uniq) loc - where - -- Any string that is somewhat unique will do - string = occNameString cl_occ ++ occNameString tycon_occ +lookupOrigNames :: [RdrName] -> RnM d NameSet +lookupOrigNames rdr_names + = mapRn lookupOrigName rdr_names `thenRn` \ names -> + returnRn (mkNameSet names) \end{code} +lookupSysBinder is used for the "system binders" of a type, class, or instance decl. +It ensures that the module is set correctly in the name cache, and sets the provenance +on the returned name too. The returned name will end up actually in the type, class, +or instance. + \begin{code} -getDFunKey :: RenamedHsType -> (OccName, OccName) -- Used to manufacture DFun names -getDFunKey (HsForAllTy _ _ ty) = getDFunKey ty -getDFunKey (MonoFunTy _ ty) = getDFunKey ty -getDFunKey (MonoDictTy cls (ty:_)) = (nameOccName cls, get_tycon_key ty) - -get_tycon_key (MonoTyVar tv) = nameOccName (getName tv) -get_tycon_key (MonoTyApp ty _) = get_tycon_key ty -get_tycon_key (MonoTupleTy tys True) = getOccName (tupleTyCon (length tys)) -get_tycon_key (MonoTupleTy tys False) = getOccName (unboxedTupleTyCon (length tys)) -get_tycon_key (MonoListTy _) = getOccName listTyCon -get_tycon_key (MonoFunTy _ _) = getOccName funTyCon +lookupSysBinder rdr_name + = ASSERT( isUnqual rdr_name ) + getModuleRn `thenRn` \ mod -> + getSrcLocRn `thenRn` \ loc -> + newTopBinder mod rdr_name loc \end{code} + %********************************************************* %* * \subsection{Binding} @@ -252,43 +300,46 @@ get_tycon_key (MonoFunTy _ _) = getOccName funTyCon %********************************************************* \begin{code} -------------------------------------- +newLocalsRn :: [(RdrName,SrcLoc)] + -> RnMS [Name] +newLocalsRn rdr_names_w_loc + = getNameSupplyRn `thenRn` \ name_supply -> + let + n = length rdr_names_w_loc + (us', us1) = splitUniqSupply (nsUniqs name_supply) + uniqs = uniqsFromSupply n us1 + names = [ mkLocalName uniq (rdrNameOcc rdr_name) loc + | ((rdr_name,loc), uniq) <- rdr_names_w_loc `zip` uniqs + ] + in + setNameSupplyRn (name_supply {nsUniqs = us'}) `thenRn_` + returnRn names + + bindLocatedLocalsRn :: SDoc -- Documentation string for error message -> [(RdrName,SrcLoc)] -> ([Name] -> RnMS a) -> RnMS a bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope - = checkDupOrQualNames doc_str rdr_names_w_loc `thenRn_` - + = getModeRn `thenRn` \ mode -> getLocalNameEnv `thenRn` \ name_env -> - (if opt_WarnNameShadowing - then - mapRn_ (check_shadow name_env) rdr_names_w_loc - else - returnRn () + + -- Check for duplicate names + checkDupOrQualNames doc_str rdr_names_w_loc `thenRn_` + + doptRn Opt_WarnNameShadowing `thenRn` \ warn_shadow -> + + -- Warn about shadowing, but only in source modules + (case mode of + SourceMode | warn_shadow -> mapRn_ (check_shadow name_env) rdr_names_w_loc + other -> returnRn () ) `thenRn_` - getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> - getModeRn `thenRn` \ mode -> - let - n = length rdr_names_w_loc - (us', us1) = splitUniqSupply us - uniqs = uniqsFromSupply n us1 - names = [ mk_name uniq (rdrNameOcc rdr_name) loc - | ((rdr_name,loc), uniq) <- rdr_names_w_loc `zip` uniqs - ] - mk_name = case mode of - SourceMode -> mkLocalName - InterfaceMode -> mkImportedLocalName - -- Keep track of whether the name originally came from - -- an interface file. - in - setNameSupplyRn (us', inst_ns, cache, ipcache) `thenRn_` - + newLocalsRn rdr_names_w_loc `thenRn` \ names -> let - new_name_env = addListToRdrEnv name_env (map fst rdr_names_w_loc `zip` names) + new_local_env = addListToRdrEnv name_env (map fst rdr_names_w_loc `zip` names) in - setLocalNameEnv new_name_env (enclosed_scope names) + setLocalNameEnv new_local_env (enclosed_scope names) where check_shadow name_env (rdr_name,loc) @@ -297,34 +348,45 @@ bindLocatedLocalsRn doc_str rdr_names_w_loc enclosed_scope Just name -> pushSrcLocRn loc $ addWarnRn (shadowedNameWarn rdr_name) -bindCoreLocalFVRn :: RdrName -> (Name -> RnMS (a, FreeVars)) - -> RnMS (a, FreeVars) +bindCoreLocalRn :: RdrName -> (Name -> RnMS a) -> RnMS a -- A specialised variant when renaming stuff from interface -- files (of which there is a lot) -- * one at a time -- * no checks for shadowing -- * always imported -- * deal with free vars -bindCoreLocalFVRn rdr_name enclosed_scope +bindCoreLocalRn rdr_name enclosed_scope = getSrcLocRn `thenRn` \ loc -> getLocalNameEnv `thenRn` \ name_env -> - getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) -> + getNameSupplyRn `thenRn` \ name_supply -> let - (us', us1) = splitUniqSupply us + (us', us1) = splitUniqSupply (nsUniqs name_supply) uniq = uniqFromSupply us1 - name = mkImportedLocalName uniq (rdrNameOcc rdr_name) loc + name = mkLocalName uniq (rdrNameOcc rdr_name) loc in - setNameSupplyRn (us', inst_ns, cache, ipcache) `thenRn_` + setNameSupplyRn (name_supply {nsUniqs = us'}) `thenRn_` let new_name_env = extendRdrEnv name_env rdr_name name in - setLocalNameEnv new_name_env (enclosed_scope name) `thenRn` \ (result, fvs) -> - returnRn (result, delFromNameSet fvs name) + setLocalNameEnv new_name_env (enclosed_scope name) + +bindCoreLocalsRn [] thing_inside = thing_inside [] +bindCoreLocalsRn (b:bs) thing_inside = bindCoreLocalRn b $ \ name' -> + bindCoreLocalsRn bs $ \ names' -> + thing_inside (name':names') + +bindLocalNames names enclosed_scope + = getLocalNameEnv `thenRn` \ name_env -> + setLocalNameEnv (addListToRdrEnv name_env pairs) + enclosed_scope + where + pairs = [(mkRdrUnqual (nameOccName n), n) | n <- names] + +bindLocalNamesFV names enclosed_scope + = bindLocalNames names $ + enclosed_scope `thenRn` \ (thing, fvs) -> + returnRn (thing, delListFromNameSet fvs names) -bindCoreLocalsFVRn [] thing_inside = thing_inside [] -bindCoreLocalsFVRn (b:bs) thing_inside = bindCoreLocalFVRn b $ \ name' -> - bindCoreLocalsFVRn bs $ \ names' -> - thing_inside (name':names') ------------------------------------- bindLocalRn doc rdr_name enclosed_scope @@ -347,58 +409,59 @@ bindLocalsFVRn doc rdr_names enclosed_scope returnRn (thing, delListFromNameSet fvs names) ------------------------------------- -bindUVarRn :: SDoc -> RdrName -> (Name -> RnMS (a, FreeVars)) -> RnMS (a, FreeVars) -bindUVarRn = bindLocalRn - -------------------------------------- -extendTyVarEnvFVRn :: [HsTyVar Name] -> RnMS (a, FreeVars) -> RnMS (a, FreeVars) - -- This tiresome function is used only in rnDecl on InstDecl +extendTyVarEnvFVRn :: [Name] -> RnMS (a, FreeVars) -> RnMS (a, FreeVars) + -- This tiresome function is used only in rnSourceDecl on InstDecl extendTyVarEnvFVRn tyvars enclosed_scope - = getLocalNameEnv `thenRn` \ env -> - let - tyvar_names = map getTyVarName tyvars - new_env = addListToRdrEnv env [ (mkRdrUnqual (getOccName name), name) - | name <- tyvar_names - ] - in - setLocalNameEnv new_env enclosed_scope `thenRn` \ (thing, fvs) -> - returnRn (thing, delListFromNameSet fvs tyvar_names) + = bindLocalNames tyvars enclosed_scope `thenRn` \ (thing, fvs) -> + returnRn (thing, delListFromNameSet fvs tyvars) -bindTyVarsRn :: SDoc -> [HsTyVar RdrName] - -> ([HsTyVar Name] -> RnMS a) +bindTyVarsRn :: SDoc -> [HsTyVarBndr RdrName] + -> ([HsTyVarBndr Name] -> RnMS a) -> RnMS a bindTyVarsRn doc_str tyvar_names enclosed_scope = bindTyVars2Rn doc_str tyvar_names $ \ names tyvars -> enclosed_scope tyvars -- Gruesome name: return Names as well as HsTyVars -bindTyVars2Rn :: SDoc -> [HsTyVar RdrName] - -> ([Name] -> [HsTyVar Name] -> RnMS a) +bindTyVars2Rn :: SDoc -> [HsTyVarBndr RdrName] + -> ([Name] -> [HsTyVarBndr Name] -> RnMS a) -> RnMS a bindTyVars2Rn doc_str tyvar_names enclosed_scope = getSrcLocRn `thenRn` \ loc -> let - located_tyvars = [(getTyVarName tv, loc) | tv <- tyvar_names] + located_tyvars = [(hsTyVarName tv, loc) | tv <- tyvar_names] in bindLocatedLocalsRn doc_str located_tyvars $ \ names -> enclosed_scope names (zipWith replaceTyVarName tyvar_names names) -bindTyVarsFVRn :: SDoc -> [HsTyVar RdrName] - -> ([HsTyVar Name] -> RnMS (a, FreeVars)) +bindTyVarsFVRn :: SDoc -> [HsTyVarBndr RdrName] + -> ([HsTyVarBndr Name] -> RnMS (a, FreeVars)) -> RnMS (a, FreeVars) bindTyVarsFVRn doc_str rdr_names enclosed_scope = bindTyVars2Rn doc_str rdr_names $ \ names tyvars -> enclosed_scope tyvars `thenRn` \ (thing, fvs) -> returnRn (thing, delListFromNameSet fvs names) -bindTyVarsFV2Rn :: SDoc -> [HsTyVar RdrName] - -> ([Name] -> [HsTyVar Name] -> RnMS (a, FreeVars)) +bindTyVarsFV2Rn :: SDoc -> [HsTyVarBndr RdrName] + -> ([Name] -> [HsTyVarBndr Name] -> RnMS (a, FreeVars)) -> RnMS (a, FreeVars) bindTyVarsFV2Rn doc_str rdr_names enclosed_scope = bindTyVars2Rn doc_str rdr_names $ \ names tyvars -> enclosed_scope names tyvars `thenRn` \ (thing, fvs) -> returnRn (thing, delListFromNameSet fvs names) +bindNakedTyVarsFVRn :: SDoc -> [RdrName] + -> ([Name] -> RnMS (a, FreeVars)) + -> RnMS (a, FreeVars) +bindNakedTyVarsFVRn doc_str tyvar_names enclosed_scope + = getSrcLocRn `thenRn` \ loc -> + let + located_tyvars = [(tv, loc) | tv <- tyvar_names] + in + bindLocatedLocalsRn doc_str located_tyvars $ \ names -> + enclosed_scope names `thenRn` \ (thing, fvs) -> + returnRn (thing, delListFromNameSet fvs names) + ------------------------------------- checkDupOrQualNames, checkDupNames :: SDoc @@ -411,7 +474,7 @@ checkDupOrQualNames doc_str rdr_names_w_loc mapRn_ (qualNameErr doc_str) quals `thenRn_` checkDupNames doc_str rdr_names_w_loc where - quals = filter (isQual.fst) rdr_names_w_loc + quals = filter (isQual . fst) rdr_names_w_loc checkDupNames doc_str rdr_names_w_loc = -- Check for duplicated names in a binding group @@ -421,170 +484,97 @@ checkDupNames doc_str rdr_names_w_loc \end{code} -%********************************************************* -%* * -\subsection{Looking up names} -%* * -%********************************************************* - -Looking up a name in the RnEnv. - -\begin{code} -lookupBndrRn rdr_name - = getNameEnvs `thenRn` \ (global_env, local_env) -> - - -- Try local env - case lookupRdrEnv local_env rdr_name of { - Just name -> returnRn name ; - Nothing -> - - getModeRn `thenRn` \ mode -> - case mode of - InterfaceMode -> -- Look in the global name cache - mkImportedGlobalFromRdrName rdr_name - - SourceMode -> -- Source mode, so look up a *qualified* version - -- of the name, so that we get the right one even - -- if there are many with the same occ name - -- There must *be* a binding - getModuleRn `thenRn` \ mod -> - case lookupRdrEnv global_env (qualifyRdrName mod rdr_name) of - Just (name:rest) -> ASSERT( null rest ) - returnRn name - Nothing -> pprPanic "lookupBndrRn" (ppr mod <+> ppr rdr_name) - } - --- Just like lookupRn except that we record the occurrence too --- Perhaps surprisingly, even wired-in names are recorded. --- Why? So that we know which wired-in names are referred to when --- deciding which instance declarations to import. -lookupOccRn :: RdrName -> RnMS Name -lookupOccRn rdr_name - = getNameEnvs `thenRn` \ (global_env, local_env) -> - lookup_occ global_env local_env rdr_name - --- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global --- environment. It's used only for --- record field names --- class op names in class and instance decls -lookupGlobalOccRn :: RdrName -> RnMS Name -lookupGlobalOccRn rdr_name - = getNameEnvs `thenRn` \ (global_env, local_env) -> - lookup_global_occ global_env rdr_name - --- Look in both local and global env -lookup_occ global_env local_env rdr_name - = case lookupRdrEnv local_env rdr_name of - Just name -> returnRn name - Nothing -> lookup_global_occ global_env rdr_name - --- Look in global env only -lookup_global_occ global_env rdr_name - = case lookupRdrEnv global_env rdr_name of - Just [name] -> returnRn name - Just stuff@(name:_) -> addNameClashErrRn rdr_name stuff `thenRn_` - returnRn name - Nothing -> getModeRn `thenRn` \ mode -> - case mode of - -- Not found when processing source code; so fail - SourceMode -> failWithRn (mkUnboundName rdr_name) - (unknownNameErr rdr_name) - - -- Not found when processing an imported declaration, - -- so we create a new name for the purpose - InterfaceMode -> mkImportedGlobalFromRdrName rdr_name -\end{code} -% -@lookupImplicitOccRn@ takes an RdrName representing an {\em original} name, -and adds it to the occurrence pool so that it'll be loaded later. -This is used when language constructs -(such as monad comprehensions, overloaded literals, or deriving clauses) -require some stuff to be loaded that isn't explicitly mentioned in the code. - -This doesn't apply in interface mode, where everything is explicit, -but we don't check for this case: -it does no harm to record an ``extra'' occurrence -and @lookupImplicitOccRn@ isn't used much in interface mode -(it's only the @Nothing@ clause of @rnDerivs@ that calls it at all I think). - - \fbox{{\em Jan 98: this comment is wrong: @rnHsType@ uses it quite a bit.}} - -For List and Tuple types it's important to get the correct -@isLocallyDefined@ flag, which is used in turn when deciding -whether there are any instance decls in this module are ``special''. -The name cache should have the correct provenance, though. - -\begin{code} -lookupImplicitOccRn :: RdrName -> RnM d Name -lookupImplicitOccRn rdr_name = mkImportedGlobalFromRdrName rdr_name -\end{code} - -@unQualInScope@ returns a function that takes a @Name@ and tells whether -its unqualified name is in scope. This is put as a boolean flag in -the @Name@'s provenance to guide whether or not to print the name qualified -in error messages. - -\begin{code} -unQualInScope :: GlobalRdrEnv -> Name -> Bool -unQualInScope env - = lookup - where - lookup name = case lookupRdrEnv env (mkRdrUnqual (nameOccName name)) of - Just [name'] -> name == name' - other -> False -\end{code} - %************************************************************************ %* * -\subsection{Envt utility functions} +\subsection{GlobalRdrEnv} %* * %************************************************************************ -\subsubsection{NameEnv}% ================ +\begin{code} +mkGlobalRdrEnv :: ModuleName -- Imported module (after doing the "as M" name change) + -> Bool -- True <=> want unqualified import + -> [AvailInfo] -- What's to be hidden (but only the unqualified + -- version is hidden) + -> (Name -> Provenance) + -> Avails -- Whats imported and how + -> GlobalRdrEnv + +mkGlobalRdrEnv this_mod unqual_imp hides mk_provenance avails + = gbl_env2 + where + -- Make the name environment. We're talking about a + -- single module here, so there must be no name clashes. + -- In practice there only ever will be if it's the module + -- being compiled. + + -- Add the things that are available + gbl_env1 = foldl add_avail emptyRdrEnv avails + + -- Delete things that are hidden + gbl_env2 = foldl del_avail gbl_env1 hides + + add_avail :: GlobalRdrEnv -> AvailInfo -> GlobalRdrEnv + add_avail env avail = foldl add_name env (availNames avail) + + add_name env name + | unqual_imp = env2 + | otherwise = env1 + where + env1 = addOneToGlobalRdrEnv env (mkRdrQual this_mod occ) (name,prov) + env2 = addOneToGlobalRdrEnv env1 (mkRdrUnqual occ) (name,prov) + occ = nameOccName name + prov = mk_provenance name + + del_avail env avail = foldl delOneFromGlobalRdrEnv env rdr_names + where + rdr_names = map (mkRdrUnqual . nameOccName) (availNames avail) + +mkIfaceGlobalRdrEnv :: [(ModuleName,Avails)] -> GlobalRdrEnv +-- Used to construct a GlobalRdrEnv for an interface that we've +-- read from a .hi file. We can't construct the original top-level +-- environment because we don't have enough info, but we compromise +-- by making an environment from its exports +mkIfaceGlobalRdrEnv m_avails + = foldl add emptyRdrEnv m_avails + where + add env (mod,avails) = plusGlobalRdrEnv env (mkGlobalRdrEnv mod True [] (\n -> LocalDef) avails) +\end{code} \begin{code} plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv plusGlobalRdrEnv env1 env2 = plusFM_C combine_globals env1 env2 -addOneToGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> Name -> GlobalRdrEnv +addOneToGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> (Name,Provenance) -> GlobalRdrEnv addOneToGlobalRdrEnv env rdr_name name = addToFM_C combine_globals env rdr_name [name] delOneFromGlobalRdrEnv :: GlobalRdrEnv -> RdrName -> GlobalRdrEnv delOneFromGlobalRdrEnv env rdr_name = delFromFM env rdr_name -combine_globals :: [Name] -- Old - -> [Name] -- New - -> [Name] +combine_globals :: [(Name,Provenance)] -- Old + -> [(Name,Provenance)] -- New + -> [(Name,Provenance)] combine_globals ns_old ns_new -- ns_new is often short = foldr add ns_old ns_new where - add n ns | any (is_duplicate n) ns_old = map choose ns -- Eliminate duplicates + add n ns | any (is_duplicate n) ns_old = map (choose n) ns -- Eliminate duplicates | otherwise = n:ns - where - choose n' | n==n' && better_provenance n n' = n - | otherwise = n' - --- Choose --- a local thing over an imported thing --- a user-imported thing over a non-user-imported thing --- an explicitly-imported thing over an implicitly imported thing -better_provenance n1 n2 - = case (getNameProvenance n1, getNameProvenance n2) of - (LocalDef _ _, _ ) -> True - (NonLocalDef (UserImport _ _ True) _, _ ) -> True - (NonLocalDef (UserImport _ _ _ ) _, NonLocalDef ImplicitImport _) -> True - other -> False - -is_duplicate :: Name -> Name -> Bool -is_duplicate n1 n2 | isLocallyDefined n1 && isLocallyDefined n2 = False - | otherwise = n1 == n2 + + choose n m | n `beats` m = n + | otherwise = m + + (n,pn) `beats` (m,pm) = n==m && pn `hasBetterProv` pm + + is_duplicate :: (Name,Provenance) -> (Name,Provenance) -> Bool + is_duplicate (n1,LocalDef) (n2,LocalDef) = False + is_duplicate (n1,_) (n2,_) = n1 == n2 \end{code} + We treat two bindings of a locally-defined name as a duplicate, because they might be two separate, local defns and we want to report and error for that, {\em not} eliminate a duplicate. On the other hand, if you import the same name from two different -import statements, we {\em d}* want to eliminate the duplicate, not report +import statements, we {\em do} want to eliminate the duplicate, not report an error. If a module imports itself then there might be a local defn and an imported @@ -592,19 +582,39 @@ defn of the same name; in this case the names will compare as equal, but will still have different provenances. +@unQualInScope@ returns a function that takes a @Name@ and tells whether +its unqualified name is in scope. This is put as a boolean flag in +the @Name@'s provenance to guide whether or not to print the name qualified +in error messages. + +\begin{code} +unQualInScope :: GlobalRdrEnv -> Name -> Bool +unQualInScope env + = (`elemNameSet` unqual_names) + where + unqual_names :: NameSet + unqual_names = foldRdrEnv add emptyNameSet env + add rdr_name [(name,_)] unquals | isUnqual rdr_name = addOneToNameSet unquals name + add _ _ unquals = unquals +\end{code} + -\subsubsection{AvailInfo}% ================ +%************************************************************************ +%* * +\subsection{Avails} +%* * +%************************************************************************ \begin{code} plusAvail (Avail n1) (Avail n2) = Avail n1 plusAvail (AvailTC n1 ns1) (AvailTC n2 ns2) = AvailTC n2 (nub (ns1 ++ ns2)) -- Added SOF 4/97 #ifdef DEBUG -plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [pprAvail a1,pprAvail a2]) +plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2]) #endif addAvail :: AvailEnv -> AvailInfo -> AvailEnv -addAvail avails avail = addToNameEnv_C plusAvail avails (availName avail) avail +addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail emptyAvailEnv = emptyNameEnv unitAvailEnv :: AvailInfo -> AvailEnv @@ -621,18 +631,15 @@ addAvailToNameSet names avail = addListToNameSet names (availNames avail) availsToNameSet :: [AvailInfo] -> NameSet availsToNameSet avails = foldl addAvailToNameSet emptyNameSet avails -availName :: AvailInfo -> Name +availName :: GenAvailInfo name -> name availName (Avail n) = n availName (AvailTC n _) = n -availNames :: AvailInfo -> [Name] +availNames :: GenAvailInfo name -> [name] availNames (Avail n) = [n] availNames (AvailTC n ns) = ns -addSysAvails :: AvailInfo -> [Name] -> AvailInfo -addSysAvails avail [] = avail -addSysAvails (AvailTC n ns) sys = AvailTC n (sys ++ ns) - +------------------------------------- filterAvail :: RdrNameIE -- Wanted -> AvailInfo -- Available -> Maybe AvailInfo -- Resulting available; @@ -668,17 +675,46 @@ filterAvail (IEThingAll _) avail@(AvailTC _ _) = Just avail filterAvail ie avail = Nothing -pprAvail :: AvailInfo -> SDoc -pprAvail (AvailTC n ns) = ppr n <> case filter (/= n) ns of - [] -> empty - ns' -> parens (hsep (punctuate comma (map ppr ns'))) +------------------------------------- +groupAvails :: Module -> Avails -> [(ModuleName, Avails)] + -- Group by module and sort by occurrence + -- This keeps the list in canonical order +groupAvails this_mod avails + = [ (mkSysModuleNameFS fs, sortLt lt avails) + | (fs,avails) <- fmToList groupFM + ] + where + groupFM :: FiniteMap FastString Avails + -- Deliberately use the FastString so we + -- get a canonical ordering + groupFM = foldl add emptyFM avails -pprAvail (Avail n) = ppr n + add env avail = addToFM_C combine env mod_fs [avail'] + where + mod_fs = moduleNameFS (moduleName avail_mod) + avail_mod = case nameModule_maybe (availName avail) of + Just m -> m + Nothing -> this_mod + combine old _ = avail':old + avail' = sortAvail avail + + a1 `lt` a2 = occ1 < occ2 + where + occ1 = nameOccName (availName a1) + occ2 = nameOccName (availName a2) + +sortAvail :: AvailInfo -> AvailInfo +-- Sort the sub-names into canonical order. +-- The canonical order has the "main name" at the beginning +-- (if it's there at all) +sortAvail (Avail n) = Avail n +sortAvail (AvailTC n ns) | n `elem` ns = AvailTC n (n : sortLt lt (filter (/= n) ns)) + | otherwise = AvailTC n ( sortLt lt ns) + where + n1 `lt` n2 = nameOccName n1 < nameOccName n2 \end{code} - - %************************************************************************ %* * \subsection{Free variable manipulation} @@ -686,23 +722,6 @@ pprAvail (Avail n) = ppr n %************************************************************************ \begin{code} -type FreeVars = NameSet - -plusFV :: FreeVars -> FreeVars -> FreeVars -addOneFV :: FreeVars -> Name -> FreeVars -unitFV :: Name -> FreeVars -emptyFVs :: FreeVars -plusFVs :: [FreeVars] -> FreeVars - -isEmptyFVs = isEmptyNameSet -emptyFVs = emptyNameSet -plusFVs = unionManyNameSets -plusFV = unionNameSets - --- No point in adding implicitly imported names to the free-var set -addOneFV s n = addOneToNameSet s n -unitFV n = unitNameSet n - -- A useful utility mapFvRn f xs = mapRn f xs `thenRn` \ stuff -> let @@ -718,92 +737,80 @@ mapFvRn f xs = mapRn f xs `thenRn` \ stuff -> %* * %************************************************************************ - - \begin{code} warnUnusedModules :: [ModuleName] -> RnM d () warnUnusedModules mods - | not opt_WarnUnusedImports = returnRn () - | otherwise = mapRn_ (addWarnRn . unused_mod) mods + = doptRn Opt_WarnUnusedImports `thenRn` \ warn -> + if warn then mapRn_ (addWarnRn . unused_mod) mods + else returnRn () where - unused_mod m = ptext SLIT("Module") <+> quotes (pprModuleName m) <+> - text "is imported, but nothing from it is used" + unused_mod m = vcat [ptext SLIT("Module") <+> quotes (ppr m) <+> + text "is imported, but nothing from it is used", + parens (ptext SLIT("except perhaps to re-export instances visible in") <+> + quotes (ppr m))] -warnUnusedLocalBinds, warnUnusedImports, warnUnusedMatches :: [Name] -> RnM d () +warnUnusedImports :: [(Name,Provenance)] -> RnM d () warnUnusedImports names - | not opt_WarnUnusedImports - = returnRn () -- Don't force names unless necessary - | otherwise - = warnUnusedBinds (const True) names + = doptRn Opt_WarnUnusedImports `thenRn` \ warn -> + if warn then warnUnusedBinds names else returnRn () -warnUnusedLocalBinds ns - | not opt_WarnUnusedBinds = returnRn () - | otherwise = warnUnusedBinds (const True) ns +warnUnusedLocalBinds, warnUnusedMatches :: [Name] -> RnM d () +warnUnusedLocalBinds names + = doptRn Opt_WarnUnusedBinds `thenRn` \ warn -> + if warn then warnUnusedBinds [(n,LocalDef) | n<-names] + else returnRn () warnUnusedMatches names - | opt_WarnUnusedMatches = warnUnusedGroup (const True) names - | otherwise = returnRn () + = doptRn Opt_WarnUnusedMatches `thenRn` \ warn -> + if warn then warnUnusedGroup [(n,LocalDef) | n<-names] + else returnRn () ------------------------- -warnUnusedBinds :: (Bool -> Bool) -> [Name] -> RnM d () -warnUnusedBinds warn_when_local names - = mapRn_ (warnUnusedGroup warn_when_local) groups +warnUnusedBinds :: [(Name,Provenance)] -> RnM d () +warnUnusedBinds names + = mapRn_ warnUnusedGroup groups where -- Group by provenance groups = equivClasses cmp names - name1 `cmp` name2 = getNameProvenance name1 `cmp_prov` getNameProvenance name2 + (_,prov1) `cmp` (_,prov2) = prov1 `compare` prov2 - cmp_prov (LocalDef _ _) (NonLocalDef _ _) = LT - cmp_prov (LocalDef loc1 _) (LocalDef loc2 _) = loc1 `compare` loc2 - cmp_prov (NonLocalDef (UserImport m1 loc1 _) _) - (NonLocalDef (UserImport m2 loc2 _) _) = - (m1 `compare` m2) `thenCmp` (loc1 `compare` loc2) - cmp_prov (NonLocalDef _ _) (LocalDef _ _) = GT - -- In-scope NonLocalDefs must have UserImport info on them ------------------------- --- NOTE: the function passed to warnUnusedGroup is --- now always (const True) so we should be able to --- simplify the code slightly. I'm leaving it there --- for now just in case I havn't realised why it was there. --- Looks highly bogus to me. SLPJ Dec 99 - -warnUnusedGroup :: (Bool -> Bool) -> [Name] -> RnM d () -warnUnusedGroup emit_warning names - | null filtered_names = returnRn () - | not (emit_warning is_local) = returnRn () +warnUnusedGroup :: [(Name,Provenance)] -> RnM d () +warnUnusedGroup names + | null filtered_names = returnRn () + | not is_local = returnRn () | otherwise = pushSrcLocRn def_loc $ addWarnRn $ - sep [msg <> colon, nest 4 (fsep (punctuate comma (map ppr filtered_names)))] + sep [msg <> colon, nest 4 (fsep (punctuate comma (map (ppr.fst) filtered_names)))] where filtered_names = filter reportable names - name1 = head filtered_names + (name1, prov1) = head filtered_names (is_local, def_loc, msg) - = case getNameProvenance name1 of - LocalDef loc _ -> (True, loc, text "Defined but not used") - NonLocalDef (UserImport mod loc _) _ -> - (True, loc, text "Imported from" <+> quotes (ppr mod) <+> - text "but not used") - other -> (False, getSrcLoc name1, text "Strangely defined but not used") - - reportable name = case occNameUserString (nameOccName name) of - ('_' : _) -> False - zz_other -> True + = case prov1 of + LocalDef -> (True, getSrcLoc name1, text "Defined but not used") + + NonLocalDef (UserImport mod loc _) + -> (True, loc, text "Imported from" <+> quotes (ppr mod) <+> text "but not used") + + reportable (name,_) = case occNameUserString (nameOccName name) of + ('_' : _) -> False + zz_other -> True -- Haskell 98 encourages compilers to suppress warnings about -- unused names in a pattern if they start with "_". \end{code} \begin{code} -addNameClashErrRn rdr_name (name1:names) +addNameClashErrRn rdr_name (np1:nps) = addErrRn (vcat [ptext SLIT("Ambiguous occurrence") <+> quotes (ppr rdr_name), ptext SLIT("It could refer to") <+> vcat (msg1 : msgs)]) where - msg1 = ptext SLIT("either") <+> mk_ref name1 - msgs = [ptext SLIT(" or") <+> mk_ref name | name <- names] - mk_ref name = quotes (ppr name) <> comma <+> pprNameProvenance name + msg1 = ptext SLIT("either") <+> mk_ref np1 + msgs = [ptext SLIT(" or") <+> mk_ref np | np <- nps] + mk_ref (name,prov) = quotes (ppr name) <> comma <+> pprNameProvenance name prov fixityClashErr (rdr_name, ((_,how_in_scope1), (_, how_in_scope2))) = hang (hsep [ptext SLIT("Conflicting fixities for"), quotes (ppr rdr_name)])