#include "HsVersions.h"
-import {-# SOURCE #-} HsExpr ( pprExpr, HsExpr )
-import {-# SOURCE #-} HsMatches ( pprMatches, Match, pprGRHSs, GRHSs )
+import {-# SOURCE #-} HsExpr ( HsExpr, pprExpr,
+ Match, pprFunBind,
+ GRHSs, pprPatBind )
-- friends:
-import HsTypes ( HsType, cmpHsType )
-import HsImpExp ( IE(..), ieName )
+import HsImpExp ( ppr_var )
+import HsTypes ( HsType )
import CoreSyn ( CoreExpr )
-import PprCore () -- Instances for Outputable
+import PprCore ( {- instance Outputable (Expr a) -} )
--others:
-import Id ( Id )
-import Name ( Name, isUnboundName )
+import Name ( Name )
+import PrelNames ( isUnboundName )
import NameSet ( NameSet, elemNameSet, nameSetToList )
-import BasicTypes ( RecFlag(..), Fixity )
+import BasicTypes ( RecFlag(..), Fixity, Activation(..) )
import Outputable
-import Bag
import SrcLoc ( SrcLoc )
import Var ( TyVar )
-import Util ( thenCmp )
+import Class ( DefMeth (..) )
\end{code}
%************************************************************************
ppr_binds EmptyBinds = empty
ppr_binds (ThenBinds binds1 binds2)
- = ($$) (ppr_binds binds1) (ppr_binds binds2)
+ = ppr_binds binds1 $$ ppr_binds binds2
ppr_binds (MonoBind bind sigs is_rec)
- = vcat [ifNotPprForUser (ptext rec_str),
+ = vcat [ppr_isrec,
vcat (map ppr sigs),
ppr bind
]
where
- rec_str = case is_rec of
- Recursive -> SLIT("{- rec -}")
- NonRecursive -> SLIT("{- nonrec -}")
+ ppr_isrec = getPprStyle $ \ sty ->
+ if userStyle sty then empty else
+ case is_rec of
+ Recursive -> ptext SLIT("{- rec -}")
+ NonRecursive -> ptext SLIT("{- nonrec -}")
\end{code}
%************************************************************************
-- and variables f = \x -> e
-- Reason: the Match stuff lets us have an optional
-- result type sig f :: a->a = ...mentions a...
+ --
+ -- This also means that instance decls can only have
+ -- FunMonoBinds, so if you change this, you'll need to
+ -- change e.g. rnMethodBinds
Bool -- True => infix declaration
[Match id pat]
SrcLoc
ppr_monobind (AndMonoBinds binds1 binds2)
= ppr_monobind binds1 $$ ppr_monobind binds2
-ppr_monobind (PatMonoBind pat grhss locn)
- = sep [ppr pat, nest 4 (pprGRHSs False grhss)]
-
-ppr_monobind (FunMonoBind fun inf matches locn)
- = pprMatches (False, ppr fun) matches
+ppr_monobind (PatMonoBind pat grhss locn) = pprPatBind pat grhss
+ppr_monobind (FunMonoBind fun inf matches locn) = pprFunBind fun matches
-- ToDo: print infix if appropriate
ppr_monobind (VarMonoBind name expr)
SrcLoc
| ClassOpSig name -- Selector name
- name -- Default-method name (if any)
- Bool -- True <=> there is an explicit, programmer-supplied
- -- default declaration in the class decl
+ (DefMeth name) -- Default-method info
+ -- See "THE NAMING STORY" in HsDecls
(HsType name)
SrcLoc
(HsType name) -- ... to these types
SrcLoc
- | InlineSig name -- INLINE f
- (Maybe Int) -- phase
- SrcLoc
-
- | NoInlineSig name -- NOINLINE f
- (Maybe Int) -- phase
+ | InlineSig Bool -- True <=> INLINE f, False <=> NOINLINE f
+ name -- Function name
+ Activation -- When inlining is *active*
SrcLoc
| SpecInstSig (HsType name) -- (Class tys); should be a specialisation of the
| FixSig (FixitySig name) -- Fixity declaration
- | DeprecSig (Deprecation name) -- DEPRECATED
- SrcLoc
-
-data FixitySig name = FixitySig name Fixity SrcLoc
--- We use exported entities for things to deprecate. Cunning trick (hack?):
--- `IEModuleContents undefined' is used for module deprecation.
-data Deprecation name = Deprecation (IE name) DeprecTxt
+data FixitySig name = FixitySig name Fixity SrcLoc
-type DeprecTxt = FAST_STRING -- reason/explanation for deprecation
+instance Eq name => Eq (FixitySig name) where
+ (FixitySig n1 f1 _) == (FixitySig n2 f2 _) = n1==n2 && f1==f2
\end{code}
\begin{code}
okBindSig :: NameSet -> Sig Name -> Bool
-okBindSig ns (ClassOpSig _ _ _ _ _) = False
+okBindSig ns (ClassOpSig _ _ _ _) = False
okBindSig ns sig = sigForThisGroup ns sig
okClsDclSig :: NameSet -> Sig Name -> Bool
Just n | isUnboundName n -> True -- Don't complain about an unbound name again
| otherwise -> n `elemNameSet` ns
-sigsForMe :: (name -> Bool) -> [Sig name] -> [Sig name]
-sigsForMe f sigs
- = filter sig_for_me sigs
- where
- sig_for_me sig = case sigName sig of
- Nothing -> False
- Just n -> f n
-
sigName :: Sig name -> Maybe name
-sigName (Sig n _ _) = Just n
-sigName (ClassOpSig n _ _ _ _) = Just n
-sigName (SpecSig n _ _) = Just n
-sigName (InlineSig n _ _) = Just n
-sigName (NoInlineSig n _ _) = Just n
-sigName (FixSig (FixitySig n _ _)) = Just n
-sigName (DeprecSig (Deprecation d _) _) = case d of
- IEModuleContents _ -> Nothing
- other -> Just (ieName d)
-sigName other = Nothing
+sigName (Sig n _ _) = Just n
+sigName (ClassOpSig n _ _ _) = Just n
+sigName (SpecSig n _ _) = Just n
+sigName (InlineSig _ n _ _) = Just n
+sigName (FixSig (FixitySig n _ _)) = Just n
+sigName other = Nothing
isFixitySig :: Sig name -> Bool
isFixitySig (FixSig _) = True
isFixitySig _ = False
isClassOpSig :: Sig name -> Bool
-isClassOpSig (ClassOpSig _ _ _ _ _) = True
-isClassOpSig _ = False
+isClassOpSig (ClassOpSig _ _ _ _) = True
+isClassOpSig _ = False
isPragSig :: Sig name -> Bool
-- Identifies pragmas
isPragSig (SpecSig _ _ _) = True
-isPragSig (InlineSig _ _ _) = True
-isPragSig (NoInlineSig _ _ _) = True
+isPragSig (InlineSig _ _ _ _) = True
isPragSig (SpecInstSig _ _) = True
-isPragSig (DeprecSig _ _) = True
isPragSig other = False
\end{code}
\begin{code}
hsSigDoc (Sig _ _ loc) = (SLIT("type signature"),loc)
-hsSigDoc (ClassOpSig _ _ _ _ loc) = (SLIT("class-method type signature"), loc)
+hsSigDoc (ClassOpSig _ _ _ loc) = (SLIT("class-method type signature"), loc)
hsSigDoc (SpecSig _ _ loc) = (SLIT("SPECIALISE pragma"),loc)
-hsSigDoc (InlineSig _ _ loc) = (SLIT("INLINE pragma"),loc)
-hsSigDoc (NoInlineSig _ _ loc) = (SLIT("NOINLINE pragma"),loc)
+hsSigDoc (InlineSig True _ _ loc) = (SLIT("INLINE pragma"),loc)
+hsSigDoc (InlineSig False _ _ loc) = (SLIT("NOINLINE pragma"),loc)
hsSigDoc (SpecInstSig _ loc) = (SLIT("SPECIALISE instance pragma"),loc)
hsSigDoc (FixSig (FixitySig _ _ loc)) = (SLIT("fixity declaration"), loc)
-hsSigDoc (DeprecSig _ loc) = (SLIT("DEPRECATED pragma"), loc)
\end{code}
\begin{code}
ppr_sig (Sig var ty _)
= sep [ppr var <+> dcolon, nest 4 (ppr ty)]
-ppr_sig (ClassOpSig var _ _ ty _)
- = sep [ppr var <+> dcolon, nest 4 (ppr ty)]
+ppr_sig (ClassOpSig var dm ty _)
+ = sep [ ppr_var var <+> dcolon,
+ nest 4 (ppr ty),
+ nest 4 (pp_dm_comment) ]
+ where
+ pp_dm = case dm of
+ DefMeth _ -> equals -- Default method indicator
+ GenDefMeth -> semi -- Generic method indicator
+ NoDefMeth -> empty -- No Method at all
+ pp_dm_comment = case dm of
+ DefMeth _ -> text "{- has default method -}"
+ GenDefMeth -> text "{- has generic method -}"
+ NoDefMeth -> empty -- No Method at all
ppr_sig (SpecSig var ty _)
= sep [ hsep [text "{-# SPECIALIZE", ppr var, dcolon],
nest 4 (ppr ty <+> text "#-}")
]
-ppr_sig (InlineSig var phase _)
- = hsep [text "{-# INLINE", ppr_phase phase, ppr var, text "#-}"]
+ppr_sig (InlineSig True var phase _)
+ = hsep [text "{-# INLINE", ppr phase, ppr var, text "#-}"]
-ppr_sig (NoInlineSig var phase _)
- = hsep [text "{-# NOINLINE", ppr_phase phase, ppr var, text "#-}"]
+ppr_sig (InlineSig False var phase _)
+ = hsep [text "{-# NOINLINE", ppr phase, ppr var, text "#-}"]
ppr_sig (SpecInstSig ty _)
= hsep [text "{-# SPECIALIZE instance", ppr ty, text "#-}"]
ppr_sig (FixSig fix_sig) = ppr fix_sig
-ppr_sig (DeprecSig deprec _) = ppr deprec
instance Outputable name => Outputable (FixitySig name) where
ppr (FixitySig name fixity loc) = sep [ppr fixity, ppr name]
-
-instance Outputable name => Outputable (Deprecation name) where
- ppr (Deprecation (IEModuleContents _) txt)
- = hsep [text "{-# DEPRECATED", doubleQuotes (ppr txt), text "#-}"]
- ppr (Deprecation thing txt)
- = hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"]
-
-ppr_phase :: Maybe Int -> SDoc
-ppr_phase Nothing = empty
-ppr_phase (Just n) = int n
\end{code}
Checking for distinct signatures; oh, so boring
\begin{code}
-cmpHsSig :: Sig Name -> Sig Name -> Ordering
-cmpHsSig (Sig n1 _ _) (Sig n2 _ _) = n1 `compare` n2
-cmpHsSig (DeprecSig (Deprecation ie1 _) _)
- (DeprecSig (Deprecation ie2 _) _) = cmp_ie ie1 ie2
-cmpHsSig (InlineSig n1 _ _) (InlineSig n2 _ _) = n1 `compare` n2
-cmpHsSig (NoInlineSig n1 _ _) (NoInlineSig n2 _ _) = n1 `compare` n2
-
-cmpHsSig (SpecInstSig ty1 _) (SpecInstSig ty2 _) = cmpHsType compare ty1 ty2
-cmpHsSig (SpecSig n1 ty1 _) (SpecSig n2 ty2 _)
- = -- may have many specialisations for one value;
+eqHsSig :: Sig Name -> Sig Name -> Bool
+eqHsSig (Sig n1 _ _) (Sig n2 _ _) = n1 == n2
+eqHsSig (InlineSig b1 n1 _ _)(InlineSig b2 n2 _ _) = b1 == b2 && n1 == n2
+
+eqHsSig (SpecInstSig ty1 _) (SpecInstSig ty2 _) = ty1 == ty2
+eqHsSig (SpecSig n1 ty1 _) (SpecSig n2 ty2 _) =
+ -- may have many specialisations for one value;
-- but not ones that are exactly the same...
- thenCmp (n1 `compare` n2) (cmpHsType compare ty1 ty2)
-
-cmpHsSig other_1 other_2 -- Tags *must* be different
- | (sig_tag other_1) _LT_ (sig_tag other_2) = LT
- | otherwise = GT
-
-cmp_ie :: IE Name -> IE Name -> Ordering
-cmp_ie (IEVar n1 ) (IEVar n2 ) = n1 `compare` n2
-cmp_ie (IEThingAbs n1 ) (IEThingAbs n2 ) = n1 `compare` n2
-cmp_ie (IEThingAll n1 ) (IEThingAll n2 ) = n1 `compare` n2
--- Hmmm...
-cmp_ie (IEThingWith n1 _) (IEThingWith n2 _) = n1 `compare` n2
-cmp_ie (IEModuleContents _ ) (IEModuleContents _ ) = EQ
-
-sig_tag (Sig n1 _ _) = (ILIT(1) :: FAST_INT)
-sig_tag (SpecSig n1 _ _) = ILIT(2)
-sig_tag (InlineSig n1 _ _) = ILIT(3)
-sig_tag (NoInlineSig n1 _ _) = ILIT(4)
-sig_tag (SpecInstSig _ _) = ILIT(5)
-sig_tag (FixSig _) = ILIT(6)
-sig_tag (DeprecSig _ _) = ILIT(7)
-sig_tag _ = panic# "tag(RnBinds)"
+ (n1 == n2) && (ty1 == ty2)
+
+eqHsSig _other1 _other2 = False
\end{code}
projects / ghc-hetmet.git / blobdiff