import RnMonad
import Name ( Name, Provenance(..), ExportFlag(..), NamedThing(..),
ImportReason(..), getSrcLoc,
- mkLocalName, mkImportedLocalName, mkGlobalName, isSystemName,
- nameOccName, setNameModule,
+ mkLocalName, mkImportedLocalName, mkGlobalName,
+ mkIPName, isSystemName,
+ nameOccName, setNameModule, nameModule,
pprOccName, isLocallyDefined, nameUnique, nameOccName,
+ occNameUserString,
setNameProvenance, getNameProvenance, pprNameProvenance
)
import NameSet
import OccName ( OccName,
- mkDFunOcc,
+ mkDFunOcc, occNameUserString, occNameString,
occNameFlavour
)
import TysWiredIn ( tupleTyCon, unboxedTupleTyCon, listTyCon )
%*********************************************************
\begin{code}
-newImportedBinder :: Module -> RdrName -> RnM d Name
--- Make a new imported binder. It might be in the cache already,
--- but if so it will have a dopey provenance, so replace it.
-newImportedBinder mod rdr_name
- = ASSERT2( isUnqual rdr_name, ppr rdr_name )
-
- -- First check the cache
- getNameSupplyRn `thenRn` \ (us, inst_ns, cache) ->
- let
- occ = rdrNameOcc rdr_name
- key = (moduleName mod, occ)
- in
- case lookupFM cache key of
-
- -- A hit in the cache!
- -- Overwrite the thing in the cache with a Name whose Module and Provenance
- -- is correct. It might be in the cache arising from an *occurrence*,
- -- whereas we are now at the binding site.
- -- Similarly for known-key things.
- -- For example, GHCmain.lhs imports as SOURCE
- -- Main; but Main.main is a known-key thing.
- Just name -> getOmitQualFn `thenRn` \ omit_fn ->
- let
- new_name = setNameProvenance (setNameModule name mod)
- (NonLocalDef ImplicitImport (omit_fn name))
- new_cache = addToFM cache key new_name
- in
- setNameSupplyRn (us, inst_ns, new_cache) `thenRn_`
- returnRn new_name
-
- Nothing -> -- Miss in the cache!
- -- Build a new original name, and put it in the cache
- getOmitQualFn `thenRn` \ omit_fn ->
- let
- (us', us1) = splitUniqSupply us
- uniq = uniqFromSupply us1
- name = mkGlobalName uniq mod occ (NonLocalDef ImplicitImport (omit_fn name))
- -- For in-scope things we improve the provenance
- -- in RnNames.importsFromImportDecl
- new_cache = addToFM cache key name
- in
- setNameSupplyRn (us', inst_ns, new_cache) `thenRn_`
- returnRn name
-
-
--- Make an imported global name, checking first to see if it's in the cache
-mkImportedGlobalName :: ModuleName -> OccName -> RnM d Name
-mkImportedGlobalName mod_name occ
- = getNameSupplyRn `thenRn` \ (us, inst_ns, cache) ->
+newImportedGlobalName mod_name occ mod
+ = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
let
key = (mod_name, occ)
in
case lookupFM cache key of
Just name -> returnRn name
- Nothing -> setNameSupplyRn (us', inst_ns, new_cache) `thenRn_`
+ Nothing -> setNameSupplyRn (us', inst_ns, new_cache, ipcache) `thenRn_`
returnRn name
where
(us', us1) = splitUniqSupply us
uniq = uniqFromSupply us1
- name = mkGlobalName uniq (mkVanillaModule mod_name) occ
- (NonLocalDef ImplicitImport False)
+ name = mkGlobalName uniq mod occ (NonLocalDef ImplicitImport False)
new_cache = addToFM cache key name
+
+updateProvenances :: [Name] -> RnM d ()
+updateProvenances names
+ = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
+ setNameSupplyRn (us, inst_ns, update cache names, ipcache)
+ where
+ update cache [] = cache
+ update cache (name:names) = WARN( not (key `elemFM` cache), ppr name )
+ update (addToFM cache key name) names
+ where
+ key = (moduleName (nameModule name), nameOccName name)
+
+newImportedBinder :: Module -> RdrName -> RnM d Name
+newImportedBinder mod rdr_name
+ = ASSERT2( isUnqual rdr_name, ppr rdr_name )
+ newImportedGlobalName (moduleName mod) (rdrNameOcc rdr_name) mod
+
+-- Make an imported global name, checking first to see if it's in the cache
+mkImportedGlobalName :: ModuleName -> OccName -> RnM d Name
+mkImportedGlobalName mod_name occ
+ = lookupModuleRn mod_name `thenRn` \ mod ->
+ newImportedGlobalName mod_name occ mod --(mkVanillaModule mod_name)
mkImportedGlobalFromRdrName rdr_name
| isQual rdr_name
-> RnM d Name
newLocalTopBinder mod occ rec_exp_fn loc
= -- First check the cache
- getNameSupplyRn `thenRn` \ (us, inst_ns, cache) ->
+ getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
let
key = (moduleName mod,occ)
mk_prov name = LocalDef loc (rec_exp_fn name)
new_name = setNameProvenance name (mk_prov new_name)
new_cache = addToFM cache key new_name
in
- setNameSupplyRn (us, inst_ns, new_cache) `thenRn_`
+ setNameSupplyRn (us, inst_ns, new_cache, ipcache) `thenRn_`
returnRn new_name
-- Miss in the cache!
new_name = mkGlobalName uniq mod occ (mk_prov new_name)
new_cache = addToFM cache key new_name
in
- setNameSupplyRn (us', inst_ns, new_cache) `thenRn_`
+ setNameSupplyRn (us', inst_ns, new_cache, ipcache) `thenRn_`
returnRn new_name
+
+getIPName rdr_name
+ = getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
+ case lookupFM ipcache key of
+ Just name -> returnRn name
+ Nothing -> setNameSupplyRn (us', inst_ns, cache, new_ipcache) `thenRn_`
+ returnRn name
+ where
+ (us', us1) = splitUniqSupply us
+ uniq = uniqFromSupply us1
+ name = mkIPName uniq key
+ new_ipcache = addToFM ipcache key name
+ where key = (rdrNameOcc rdr_name)
\end{code}
%*********************************************************
%* *
-\subsection{Dfuns and default methods
+\subsection{Dfuns and default methods}
%* *
%*********************************************************
-@newImplicitBinder@ is used for (a) dfuns (b) default methods, defined in this module
+@newImplicitBinder@ is used for (a) dfuns
+(b) default methods, defined in this module.
\begin{code}
newImplicitBinder occ src_loc
\begin{code}
newDFunName :: (OccName, OccName) -> SrcLoc -> RnMS Name
newDFunName key@(cl_occ, tycon_occ) loc
- = newInstUniq key `thenRn` \ inst_uniq ->
- newImplicitBinder (mkDFunOcc cl_occ tycon_occ inst_uniq) 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
\end{code}
\begin{code}
\begin{code}
-------------------------------------
-bindLocatedLocalsRn :: SDoc -- Documentation string for error message
+bindLocatedLocalsRn :: SDoc -- Documentation string for error message
-> [(RdrName,SrcLoc)]
-> ([Name] -> RnMS a)
-> RnMS a
returnRn ()
) `thenRn_`
- getNameSupplyRn `thenRn` \ (us, inst_ns, cache) ->
+ getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
getModeRn `thenRn` \ mode ->
let
n = length rdr_names_w_loc
-- Keep track of whether the name originally came from
-- an interface file.
in
- setNameSupplyRn (us', inst_ns, cache) `thenRn_`
+ setNameSupplyRn (us', inst_ns, cache, ipcache) `thenRn_`
let
new_name_env = addListToRdrEnv name_env (map fst rdr_names_w_loc `zip` names)
bindCoreLocalFVRn rdr_name enclosed_scope
= getSrcLocRn `thenRn` \ loc ->
getLocalNameEnv `thenRn` \ name_env ->
- getNameSupplyRn `thenRn` \ (us, inst_ns, cache) ->
+ getNameSupplyRn `thenRn` \ (us, inst_ns, cache, ipcache) ->
let
(us', us1) = splitUniqSupply us
uniq = uniqFromSupply us1
name = mkImportedLocalName uniq (rdrNameOcc rdr_name) loc
in
- setNameSupplyRn (us', inst_ns, cache) `thenRn_`
+ setNameSupplyRn (us', inst_ns, cache, ipcache) `thenRn_`
let
new_name_env = extendRdrEnv name_env rdr_name name
in
- setLocalNameEnv new_name_env (enclosed_scope name) `thenRn` \ (result, fvs) ->
+ setLocalNameEnv new_name_env (enclosed_scope name) `thenRn` \ (result, fvs) ->
returnRn (result, delFromNameSet fvs name)
bindCoreLocalsFVRn [] thing_inside = thing_inside []
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 tyvars enclosed_scope
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)
+ 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
-- deciding which instance declarations to import.
lookupOccRn :: RdrName -> RnMS Name
lookupOccRn rdr_name
- = getNameEnvs `thenRn` \ (global_env, local_env) ->
+ = 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
-- class op names in class and instance decls
lookupGlobalOccRn :: RdrName -> RnMS Name
lookupGlobalOccRn rdr_name
- = getNameEnvs `thenRn` \ (global_env, local_env) ->
+ = getNameEnvs `thenRn` \ (global_env, local_env) ->
lookup_global_occ global_env rdr_name
-- Look in both local and global env
-- 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.
-
--- lookupImplicitOccRn takes an RdrName representing an *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).
--- [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.
-
-lookupImplicitOccRn :: RdrName -> RnMS Name
+\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
+@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
+the @Name@'s provenance to guide whether or not to print the name qualified
in error messages.
\begin{code}
%* *
%************************************************************************
-=============== NameEnv ================
+\subsubsection{NameEnv}% ================
+
\begin{code}
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
plusGlobalRdrEnv env1 env2 = plusFM_C combine_globals env1 env2
is_duplicate :: Name -> Name -> Bool
is_duplicate n1 n2 | isLocallyDefined n1 && isLocallyDefined n2 = False
| otherwise = n1 == n2
- -- 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, *not* eliminate a duplicate.
-
- -- On the other hand, if you import the same name from two different
- -- import statements, we *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
- -- defn of the same name; in this case the names will compare as equal, but
- -- will still have different provenances
\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
+an error.
+
+If a module imports itself then there might be a local defn and an imported
+defn of the same name; in this case the names will compare as equal, but
+will still have different provenances.
+
+\subsubsection{ExportAvails}% ================
-=============== ExportAvails ================
\begin{code}
mkEmptyExportAvails :: ModuleName -> ExportAvails
mkEmptyExportAvails mod_name = (unitFM mod_name [], emptyUFM)
\end{code}
-=============== AvailInfo ================
+\subsubsection{AvailInfo}% ================
+
\begin{code}
plusAvail (Avail n1) (Avail n2) = Avail n1
plusAvail (AvailTC n1 ns1) (AvailTC n2 ns2) = AvailTC n1 (nub (ns1 ++ ns2))
-- import A( op )
-- where op is a class operation
-filterAvail (IEThingAll _) avail@(AvailTC _ _) = Just avail
+filterAvail (IEThingAll _) avail@(AvailTC _ _) = Just avail
+ -- We don't complain even if the IE says T(..), but
+ -- no constrs/class ops of T are available
+ -- Instead that's caught with a warning by the caller
filterAvail ie avail = Nothing
%************************************************************************
+
\begin{code}
-warnUnusedLocalBinds, warnUnusedTopNames, warnUnusedMatches :: [Name] -> RnM d ()
+warnUnusedLocalBinds, warnUnusedImports, warnUnusedMatches :: [Name] -> RnM d ()
-warnUnusedTopNames names
- | not opt_WarnUnusedBinds && not opt_WarnUnusedImports = returnRn () -- Don't force ns unless necessary
- | otherwise = warnUnusedBinds (\ is_local -> not is_local) names
+warnUnusedImports names
+ | not opt_WarnUnusedImports
+ = returnRn () -- Don't force names unless necessary
+ | otherwise
+ = warnUnusedBinds (const True) names
warnUnusedLocalBinds ns
| not opt_WarnUnusedBinds = returnRn ()
- | otherwise = warnUnusedBinds (\ is_local -> is_local) ns
+ | otherwise = warnUnusedBinds (const True) ns
warnUnusedMatches names
| opt_WarnUnusedMatches = warnUnusedGroup (const True) names
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)
+ (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
-------------------------
-warnUnusedGroup :: (Bool -> Bool) -> [Name] -> RnM d ()
-warnUnusedGroup _ []
- = returnRn ()
+-- 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 ()
| otherwise
= pushSrcLocRn def_loc $
addWarnRn $
- sep [msg <> colon, nest 4 (fsep (punctuate comma (map ppr names)))]
+ sep [msg <> colon, nest 4 (fsep (punctuate comma (map ppr filtered_names)))]
where
- name1 = head names
+ filtered_names = filter reportable names
+ name1 = 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")
+ 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
+ -- Haskell 98 encourages compilers to suppress warnings about
+ -- unused names in a pattern if they start with "_".
\end{code}
\begin{code}
$$
(ptext SLIT("in") <+> descriptor))
\end{code}
-
projects / ghc-hetmet.git / blobdiff