-- friends:
import HsTypes ( HsType )
import CoreSyn ( CoreExpr )
-import PprCore () -- Instances for Outputable
+import PprCore ( {- Instances -} )
--others:
-import Id ( Id )
-import NameSet ( NameSet, nameSetToList )
+import Name ( Name, isUnboundName )
+import NameSet ( NameSet, elemNameSet, nameSetToList )
import BasicTypes ( RecFlag(..), Fixity )
import Outputable
-import Bag
import SrcLoc ( SrcLoc )
import Var ( TyVar )
\end{code}
| AndMonoBinds (MonoBinds id pat)
(MonoBinds id pat)
- | PatMonoBind pat
- (GRHSs id pat)
- SrcLoc
-
- | FunMonoBind id
+ | FunMonoBind id -- Used for both functions f x = e
+ -- and variables f = \x -> e
+ -- Reason: the Match stuff lets us have an optional
+ -- result type sig f :: a->a = ...mentions a...
Bool -- True => infix declaration
[Match id pat]
SrcLoc
+ | PatMonoBind pat -- The pattern is never a simple variable;
+ -- That case is done by FunMonoBind
+ (GRHSs id pat)
+ SrcLoc
+
| VarMonoBind id -- TRANSLATION
(HsExpr id pat)
loop2 acc (b:bs) = loop2 (acc `AndMonoBinds` b) bs
\end{code}
+
\begin{code}
instance (Outputable id, Outputable pat) =>
Outputable (MonoBinds id pat) where
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
+ (Maybe -- Nothing for source-file class signatures
+ (name, -- Default-method name (if any)
+ Bool)) -- True <=> there is an explicit, programmer-supplied
+ -- default declaration in the class decl
(HsType name)
SrcLoc
| FixSig (FixitySig name) -- Fixity declaration
- | DeprecSig (Deprecation name) -- DEPRECATED
- SrcLoc
-
-
-data FixitySig name = FixitySig name Fixity SrcLoc
-data Deprecation name
- = DeprecMod DeprecTxt -- deprecation of a whole module
- | DeprecName name DeprecTxt -- deprecation of a single name
+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}
-sigsForMe :: (name -> Bool) -> [Sig name] -> [Sig name]
-sigsForMe f sigs
- = filter sig_for_me sigs
- where
- sig_for_me (Sig n _ _) = f n
- sig_for_me (ClassOpSig n _ _ _ _) = f n
- sig_for_me (SpecSig n _ _) = f n
- sig_for_me (InlineSig n _ _) = f n
- sig_for_me (NoInlineSig n _ _) = f n
- sig_for_me (SpecInstSig _ _) = False
- sig_for_me (FixSig (FixitySig n _ _)) = f n
- sig_for_me (DeprecSig (DeprecMod _) _) = False
- sig_for_me (DeprecSig (DeprecName n _) _) = f n
+okBindSig :: NameSet -> Sig Name -> Bool
+okBindSig ns (ClassOpSig _ _ _ _) = False
+okBindSig ns sig = sigForThisGroup ns sig
+
+okClsDclSig :: NameSet -> Sig Name -> Bool
+okClsDclSig ns (Sig _ _ _) = False
+okClsDclSig ns sig = sigForThisGroup ns sig
+
+okInstDclSig :: NameSet -> Sig Name -> Bool
+okInstDclSig ns (Sig _ _ _) = False
+okInstDclSig ns (FixSig _) = False
+okInstDclSig ns (SpecInstSig _ _) = True
+okInstDclSig ns sig = sigForThisGroup ns sig
+
+sigForThisGroup ns sig
+ = case sigName sig of
+ Nothing -> False
+ Just n | isUnboundName n -> True -- Don't complain about an unbound name again
+ | otherwise -> n `elemNameSet` ns
+
+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 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 (InlineSig _ _ _) = True
isPragSig (NoInlineSig _ _ _) = 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 (SpecSig _ _ loc) = (SLIT("SPECIALISE pragma"),loc)
+hsSigDoc (InlineSig _ _ loc) = (SLIT("INLINE pragma"),loc)
+hsSigDoc (NoInlineSig _ _ loc) = (SLIT("NOINLINE pragma"),loc)
+hsSigDoc (SpecInstSig _ loc) = (SLIT("SPECIALISE instance pragma"),loc)
+hsSigDoc (FixSig (FixitySig _ _ loc)) = (SLIT("fixity declaration"), loc)
+\end{code}
+
+\begin{code}
instance (Outputable name) => Outputable (Sig name) where
ppr sig = ppr_sig sig
-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 (DeprecMod txt)
- = hsep [text "{-# DEPRECATED", doubleQuotes (ppr txt), text "#-}"]
- ppr (DeprecName n txt)
- = hsep [text "{-# DEPRECATED", ppr n, doubleQuotes (ppr txt), text "#-}"]
-
+ppr_sig :: Outputable name => Sig name -> SDoc
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 <+> pp_dm <+> dcolon, nest 4 (ppr ty)]
+ where
+ pp_dm = case dm of
+ Just (_, True) -> equals -- Default-method indicator
+ other -> empty
ppr_sig (SpecSig var ty _)
= sep [ hsep [text "{-# SPECIALIZE", ppr var, dcolon],
ppr_sig (FixSig fix_sig) = ppr fix_sig
-ppr_sig (DeprecSig deprec _) = ppr deprec
-ppr_phase Nothing = empty
+instance Outputable name => Outputable (FixitySig name) where
+ ppr (FixitySig name fixity loc) = sep [ppr fixity, ppr name]
+
+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}
+eqHsSig :: Sig Name -> Sig Name -> Bool
+eqHsSig (Sig n1 _ _) (Sig n2 _ _) = n1 == n2
+eqHsSig (InlineSig n1 _ _) (InlineSig n2 _ _) = n1 == n2
+eqHsSig (NoInlineSig n1 _ _) (NoInlineSig n2 _ _) = 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...
+ (n1 == n2) && (ty1 == ty2)
+
+eqHsSig other_1 other_2 = False
+\end{code}
projects / ghc-hetmet.git / blobdiff