X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FRnEnv.lhs;h=0d998852501adcd383898102c5a9a42cb3428762;hb=17879095049f5705c9734cab4f4c5d56f61f81a7;hp=7bd630cbd51be104f8f41fbb33c5347902760511;hpb=fe69f3c1d6062b90635963aa414c33951bf18427;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/RnEnv.lhs b/ghc/compiler/rename/RnEnv.lhs index 7bd630c..0d99885 100644 --- a/ghc/compiler/rename/RnEnv.lhs +++ b/ghc/compiler/rename/RnEnv.lhs @@ -8,44 +8,39 @@ 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 HsTypes ( hsTyVarName, hsTyVarNames, replaceTyVarName ) - +import HscTypes ( Provenance(..), pprNameProvenance, hasBetterProv, + ImportReason(..), GlobalRdrEnv, Avails, AvailEnv, + AvailInfo, GenAvailInfo(..), RdrAvailInfo ) import RnMonad -import Name ( Name, Provenance(..), ExportFlag(..), NamedThing(..), - ImportReason(..), getSrcLoc, - mkLocalName, mkImportedLocalName, mkGlobalName, mkUnboundName, - mkIPName, isWiredInName, hasBetterProv, - nameOccName, setNameModule, nameModule, - pprOccName, isLocallyDefined, nameUnique, - setNameProvenance, getNameProvenance, pprNameProvenance, - extendNameEnv_C, plusNameEnv_C, nameEnvElts +import Name ( Name, NamedThing(..), + getSrcLoc, + mkLocalName, mkImportedLocalName, mkGlobalName, + mkIPName, isLocallyDefined, + nameOccName, nameModule, + extendNameEnv_C, plusNameEnv_C, nameEnvElts, + setNameModuleAndLoc ) import NameSet -import OccName ( OccName, - mkDFunOcc, occNameUserString, occNameString, - occNameFlavour - ) -import TysWiredIn ( listTyCon ) -import Type ( funTyCon ) -import Module ( ModuleName, mkThisModule, moduleName, mkVanillaModule, pprModuleName ) +import OccName ( OccName, occNameUserString, occNameFlavour ) +import Module ( ModuleName, moduleName, mkVanillaModule ) import FiniteMap +import Unique ( Unique ) import UniqSupply import SrcLoc ( SrcLoc, noSrcLoc ) import Outputable -import Util ( removeDups, equivClasses, thenCmp, sortLt ) +import ListSetOps ( removeDups, equivClasses ) +import Util ( thenCmp, sortLt ) import List ( nub ) +import PrelNames ( mkUnboundName ) +import CmdLineOpts \end{code} - - %********************************************************* %* * \subsection{Making new names} @@ -53,40 +48,27 @@ import List ( nub ) %********************************************************* \begin{code} -implicitImportProvenance = NonLocalDef ImplicitImport False - -newTopBinder :: Module -> OccName -> RnM d Name -newTopBinder mod occ +newTopBinder :: Module -> RdrName -> SrcLoc -> RnM d Name +newTopBinder mod rdr_name loc = -- First check the cache - traceRn (text "newTopBinder" <+> ppr mod <+> ppr occ) `thenRn_` + traceRn (text "newTopBinder" <+> ppr mod <+> ppr loc) `thenRn_` getNameSupplyRn `thenRn` \ (us, cache, ipcache) -> let + occ = rdrNameOcc rdr_name key = (moduleName mod, occ) in case lookupFM cache key of - -- A hit in the cache! We are at the binding site of the name, which is - -- the time we know all about the Name's host Module (in particular, which - -- package it comes from), so update the Module in the name. - -- But otherwise *leave the Provenance alone*: - -- - -- * For imported names, the Provenance may already be correct. - -- e.g. We imported Prelude.hi, and set the provenance of PrelShow.Show - -- to 'UserImport from Prelude'. Note that we havn't yet opened PrelShow.hi - -- Later we find we really need PrelShow.Show, so we open PrelShow.hi, and - -- that's when we find the binding occurrence of Show. - -- - -- * For locally defined names, we do a setProvenance on the Name - -- right after newTopBinder, and then use updateProveances to finally - -- set the provenances in the cache correctly. - -- - -- NB: for wired-in names it's important not to - -- forget that they are wired in even when compiling that module - -- (else we spit out redundant defns into the interface file) + -- 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 = setNameModule name mod + new_name = setNameModuleAndLoc name mod loc new_cache = addToFM cache key new_name in setNameSupplyRn (us, new_cache, ipcache) `thenRn_` @@ -100,7 +82,7 @@ newTopBinder mod occ Nothing -> let (us', us1) = splitUniqSupply us uniq = uniqFromSupply us1 - new_name = mkGlobalName uniq mod occ implicitImportProvenance + new_name = mkGlobalName uniq mod occ loc new_cache = addToFM cache key new_name in setNameSupplyRn (us', new_cache, ipcache) `thenRn_` @@ -111,8 +93,8 @@ newTopBinder mod occ 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 + -- 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 @@ -142,10 +124,9 @@ newGlobalName mod_name occ (us', us1) = splitUniqSupply us 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 - newIPName rdr_name = getNameSupplyRn `thenRn` \ (us, cache, ipcache) -> case lookupFM ipcache key of @@ -158,34 +139,6 @@ newIPName rdr_name name = mkIPName uniq key new_ipcache = addToFM ipcache key name where key = (rdrNameOcc rdr_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, cache, ipcache) -> - setNameSupplyRn (us, 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) \end{code} %********************************************************* @@ -216,8 +169,8 @@ lookupTopBndrRn rdr_name getModuleRn `thenRn` \ mod -> getGlobalNameEnv `thenRn` \ global_env -> case lookupRdrEnv global_env (qualifyRdrName (moduleName mod) rdr_name) of - Just (name:rest) -> ASSERT( null rest ) - returnRn name + Just ((name,_):rest) -> ASSERT( null rest ) + returnRn name Nothing -> -- Almost always this case is a compiler bug. -- But consider a type signature that doesn't have -- a corresponding binder: @@ -263,9 +216,10 @@ lookupGlobalOccRn rdr_name getGlobalNameEnv `thenRn` \ global_env -> case lookupRdrEnv global_env rdr_name of - Just [name] -> returnRn name - Just stuff@(name:_) -> addNameClashErrRn rdr_name stuff `thenRn_` - returnRn name + Just [(name,_)] -> returnRn name + Just stuff@((name,_):_) + -> addNameClashErrRn rdr_name stuff `thenRn_` + returnRn name Nothing -> -- Not found when processing source code; so fail failWithRn (mkUnboundName rdr_name) (unknownNameErr rdr_name) @@ -319,29 +273,11 @@ or instance. \begin{code} lookupSysBinder rdr_name = ASSERT( isUnqual rdr_name ) - getModuleRn `thenRn` \ mod -> - newTopBinder mod (rdrNameOcc rdr_name) `thenRn` \ name -> - getModeRn `thenRn` \ mode -> - case mode of - SourceMode -> getSrcLocRn `thenRn` \ loc -> - returnRn (setNameProvenance name (LocalDef loc Exported)) - InterfaceMode -> returnRn name + getModuleRn `thenRn` \ mod -> + getSrcLocRn `thenRn` \ loc -> + newTopBinder mod rdr_name loc \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} %********************************************************* @@ -351,42 +287,54 @@ unQualInScope env %********************************************************* \begin{code} +newLocalsRn :: (Unique -> OccName -> SrcLoc -> Name) + -> [(RdrName,SrcLoc)] + -> RnMS [Name] +newLocalsRn mk_name rdr_names_w_loc + = getNameSupplyRn `thenRn` \ (us, cache, ipcache) -> + 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 + ] + in + setNameSupplyRn (us', cache, ipcache) `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 -> + = getModeRn `thenRn` \ mode -> getLocalNameEnv `thenRn` \ name_env -> - -- Warn about shadowing, but only in source modules + -- 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 | opt_WarnNameShadowing -> mapRn_ (check_shadow name_env) rdr_names_w_loc + SourceMode | warn_shadow -> mapRn_ (check_shadow name_env) rdr_names_w_loc other -> returnRn () ) `thenRn_` - getNameSupplyRn `thenRn` \ (us, cache, ipcache) -> 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', cache, ipcache) `thenRn_` - + newLocalsRn mk_name 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) @@ -456,13 +404,11 @@ bindUVarRn :: SDoc -> RdrName -> (Name -> RnMS (a, FreeVars)) -> RnMS (a, FreeVa bindUVarRn = bindLocalRn ------------------------------------- -extendTyVarEnvFVRn :: [HsTyVarBndr Name] -> RnMS (a, FreeVars) -> RnMS (a, FreeVars) +extendTyVarEnvFVRn :: [Name] -> RnMS (a, FreeVars) -> RnMS (a, FreeVars) -- This tiresome function is used only in rnDecl on InstDecl extendTyVarEnvFVRn tyvars enclosed_scope - = bindLocalNames tyvar_names enclosed_scope `thenRn` \ (thing, fvs) -> - returnRn (thing, delListFromNameSet fvs tyvar_names) - where - tyvar_names = hsTyVarNames tyvars + = bindLocalNames tyvars enclosed_scope `thenRn` \ (thing, fvs) -> + returnRn (thing, delListFromNameSet fvs tyvars) bindTyVarsRn :: SDoc -> [HsTyVarBndr RdrName] -> ([HsTyVarBndr Name] -> RnMS a) @@ -499,6 +445,18 @@ bindTyVarsFV2Rn doc_str rdr_names enclosed_scope 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 @@ -523,38 +481,37 @@ checkDupNames doc_str rdr_names_w_loc %************************************************************************ %* * -\subsection{Envt utility functions} +\subsection{GlobalRdrEnv} %* * %************************************************************************ -\subsubsection{NameEnv}% ================ - \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 m | n==m && n `hasBetterProv` m = n - | otherwise = m + choose n m | n `beats` m = n + | otherwise = m + + (n,pn) `beats` (m,pm) = n==m && pn `hasBetterProv` pm -is_duplicate :: Name -> Name -> Bool -is_duplicate n1 n2 | isLocallyDefined n1 && isLocallyDefined n2 = False - | otherwise = n1 == n2 + 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, @@ -562,7 +519,7 @@ 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 @@ -570,8 +527,27 @@ 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 + = lookup + where + lookup name = case lookupRdrEnv env (mkRdrUnqual (nameOccName name)) of + Just [(name',_)] -> name == name' + other -> False +\end{code} + -\subsubsection{AvailInfo}% ================ +%************************************************************************ +%* * +\subsection{Avails} +%* * +%************************************************************************ \begin{code} plusAvail (Avail n1) (Avail n2) = Avail n1 @@ -661,8 +637,6 @@ pprAvail (Avail n) = ppr n \end{code} - - %************************************************************************ %* * \subsection{Free variable manipulation} @@ -677,11 +651,13 @@ addOneFV :: FreeVars -> Name -> FreeVars unitFV :: Name -> FreeVars emptyFVs :: FreeVars plusFVs :: [FreeVars] -> FreeVars +mkFVs :: [Name] -> FreeVars isEmptyFVs = isEmptyNameSet emptyFVs = emptyNameSet plusFVs = unionManyNameSets plusFV = unionNameSets +mkFVs = mkNameSet -- No point in adding implicitly imported names to the free-var set addOneFV s n = addOneToNameSet s n @@ -702,94 +678,80 @@ mapFvRn f xs = mapRn f xs `thenRn` \ stuff -> %* * %************************************************************************ - - \begin{code} -warnUnusedModules :: [ModuleName] -> RnM d () +warnUnusedModules :: [Module] -> 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 = vcat [ptext SLIT("Module") <+> quotes (pprModuleName m) <+> + 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 (pprModuleName m))] + quotes (ppr (moduleName 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)])