-- 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 )
+import Class ( DefMeth (..) )
\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
(HsType name)
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
+ | ClassOpSig name -- Selector name
+ (Maybe (DefMeth name)) -- Nothing for source-file class signatures
+ -- Gives DefMeth info for interface files sigs
(HsType name)
SrcLoc
-- current instance decl
SrcLoc
- | FixSig (FixitySig name) -- Fixity declaration
+ | FixSig (FixitySig name) -- Fixity declaration
-data FixitySig name = FixitySig name Fixity SrcLoc
+data FixitySig name = FixitySig name Fixity SrcLoc
+
+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
+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
\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]
-
-
+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 (DefMeth _) -> equals -- Default method indicator
+ Just GenDefMeth -> semi -- Generic method indicator
+ Just NoDefMeth -> empty -- No Method at all
+ -- Not convinced this is right...
+ -- Not used in interface file output hopefully
+ -- but needed for ddump-rn ??
+ other -> dot
+ -- empty -- No method at all
+
ppr_sig (SpecSig var ty _)
= sep [ hsep [text "{-# SPECIALIZE", ppr var, dcolon],
]
ppr_sig (InlineSig var phase _)
- = hsep [text "{-# INLINE", ppr_phase phase, ppr var, text "#-}"]
+ = hsep [text "{-# INLINE", ppr_phase phase, ppr var, text "#-}"]
ppr_sig (NoInlineSig var phase _)
- = hsep [text "{-# NOINLINE", ppr_phase phase, ppr var, text "#-}"]
+ = hsep [text "{-# NOINLINE", ppr_phase phase, ppr var, text "#-}"]
ppr_sig (SpecInstSig ty _)
= hsep [text "{-# SPECIALIZE instance", ppr ty, text "#-}"]
ppr_sig (FixSig fix_sig) = ppr fix_sig
-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