%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[HsBinds]{Abstract syntax: top-level bindings and signatures}
Datatype for: @HsBinds@, @Bind@, @Sig@, @MonoBinds@.
\begin{code}
-#include "HsVersions.h"
-
module HsBinds where
-IMP_Ubiq()
+#include "HsVersions.h"
+
+import {-# SOURCE #-} HsExpr ( pprExpr, HsExpr )
+import {-# SOURCE #-} HsMatches ( pprMatches, Match, pprGRHSs, GRHSs )
-- friends:
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ <= 201
-IMPORT_DELOOPER(HsLoop) ( pprMatches, pprGRHSsAndBinds,
- Match, GRHSsAndBinds,
- pprExpr, HsExpr )
-#endif
-
-import HsPragmas ( GenPragmas, ClassOpPragmas )
import HsTypes ( HsType )
-import CoreSyn ( SYN_IE(CoreExpr) )
+import CoreSyn ( CoreExpr )
+import PprCore () -- Instances for Outputable
--others:
-import Id ( SYN_IE(DictVar), SYN_IE(Id), GenId )
-import Name ( OccName, NamedThing(..) )
-import Outputable ( interpp'SP, ifnotPprForUser, pprQuote,
- Outputable(..){-instance * (,)-}
- )
-import PprCore --( GenCoreExpr {- instance Outputable -} )
-import PprType ( GenTyVar {- instance Outputable -} )
-import Pretty
+import Id ( Id )
+import NameSet ( NameSet, nameSetToList )
+import BasicTypes ( RecFlag(..), Fixity )
+import Outputable
import Bag
-import SrcLoc ( SrcLoc{-instances-} )
-import TyVar ( GenTyVar{-instances-} )
-import Unique ( Unique {- instance Eq -} )
-
-#if __GLASGOW_HASKELL__ >= 202
-import {-# SOURCE #-} HsExpr ( pprExpr, HsExpr )
-import {-# SOURCE #-} HsMatches ( pprMatches, Match, pprGRHSsAndBinds, GRHSsAndBinds )
-#endif
-
+import SrcLoc ( SrcLoc )
+import Var ( TyVar )
\end{code}
%************************************************************************
Collections of bindings, created by dependency analysis and translation:
\begin{code}
-data HsBinds tyvar uvar id pat -- binders and bindees
+data HsBinds id pat -- binders and bindees
= EmptyBinds
- | ThenBinds (HsBinds tyvar uvar id pat)
- (HsBinds tyvar uvar id pat)
+ | ThenBinds (HsBinds id pat)
+ (HsBinds id pat)
- | MonoBind (MonoBinds tyvar uvar id pat)
+ | MonoBind (MonoBinds id pat)
[Sig id] -- Empty on typechecker output
RecFlag
-
-type RecFlag = Bool
-recursive = True
-nonRecursive = False
\end{code}
\begin{code}
-nullBinds :: HsBinds tyvar uvar id pat -> Bool
+nullBinds :: HsBinds id pat -> Bool
nullBinds EmptyBinds = True
nullBinds (ThenBinds b1 b2) = nullBinds b1 && nullBinds b2
\end{code}
\begin{code}
-instance (Outputable pat, NamedThing id, Outputable id,
- Eq tyvar, Outputable tyvar, Eq uvar, Outputable uvar) =>
- Outputable (HsBinds tyvar uvar id pat) where
-
- ppr sty binds = pprQuote sty (\ sty -> ppr_binds sty binds)
-
-ppr_binds sty EmptyBinds = empty
-ppr_binds sty (ThenBinds binds1 binds2)
- = ($$) (ppr_binds sty binds1) (ppr_binds sty binds2)
-ppr_binds sty (MonoBind bind sigs is_rec)
- = vcat [
- ifnotPprForUser sty (ptext rec_str),
- if null sigs
- then empty
- else vcat (map (ppr sty) sigs),
- ppr sty bind
+instance (Outputable pat, Outputable id) =>
+ Outputable (HsBinds id pat) where
+ ppr binds = ppr_binds binds
+
+ppr_binds EmptyBinds = empty
+ppr_binds (ThenBinds binds1 binds2)
+ = ($$) (ppr_binds binds1) (ppr_binds binds2)
+ppr_binds (MonoBind bind sigs is_rec)
+ = vcat [ifNotPprForUser (ptext rec_str),
+ vcat (map ppr sigs),
+ ppr bind
]
where
- rec_str | is_rec = SLIT("{- rec -}")
- | otherwise = SLIT("{- nonrec -}")
+ rec_str = case is_rec of
+ Recursive -> SLIT("{- rec -}")
+ NonRecursive -> SLIT("{- nonrec -}")
\end{code}
%************************************************************************
Global bindings (where clauses)
\begin{code}
-data MonoBinds tyvar uvar id pat
+data MonoBinds id pat
= EmptyMonoBinds
- | AndMonoBinds (MonoBinds tyvar uvar id pat)
- (MonoBinds tyvar uvar id pat)
+ | AndMonoBinds (MonoBinds id pat)
+ (MonoBinds id pat)
| PatMonoBind pat
- (GRHSsAndBinds tyvar uvar id pat)
+ (GRHSs id pat)
SrcLoc
| FunMonoBind id
- Bool -- True => infix declaration
- [Match tyvar uvar id pat] -- must have at least one Match
+ Bool -- True => infix declaration
+ [Match id pat]
SrcLoc
| VarMonoBind id -- TRANSLATION
- (HsExpr tyvar uvar id pat)
+ (HsExpr id pat)
| CoreMonoBind id -- TRANSLATION
CoreExpr -- No zonking; this is a final CoreExpr with Ids and Types!
- | AbsBinds -- Binds abstraction; TRANSLATION
- [tyvar] -- Type variables
- [id] -- Dicts
- [([tyvar], id, id)] -- (type variables, polymorphic, momonmorphic) triples
- (MonoBinds tyvar uvar id pat) -- The "business end"
+ | AbsBinds -- Binds abstraction; TRANSLATION
+ [TyVar] -- Type variables
+ [id] -- Dicts
+ [([TyVar], id, id)] -- (type variables, polymorphic, momonmorphic) triples
+ NameSet -- Set of *polymorphic* variables that have an INLINE pragma
+ (MonoBinds id pat) -- The "business end"
-- Creates bindings for *new* (polymorphic, overloaded) locals
-- in terms of *old* (monomorphic, non-overloaded) ones.
in (fm,gm)
\begin{code}
-nullMonoBinds :: MonoBinds tyvar uvar id pat -> Bool
+nullMonoBinds :: MonoBinds id pat -> Bool
nullMonoBinds EmptyMonoBinds = True
nullMonoBinds (AndMonoBinds bs1 bs2) = nullMonoBinds bs1 && nullMonoBinds bs2
nullMonoBinds other_monobind = False
-andMonoBinds :: [MonoBinds tyvar uvar id pat] -> MonoBinds tyvar uvar id pat
-andMonoBinds binds = foldr AndMonoBinds EmptyMonoBinds binds
+andMonoBinds :: MonoBinds id pat -> MonoBinds id pat -> MonoBinds id pat
+andMonoBinds EmptyMonoBinds mb = mb
+andMonoBinds mb EmptyMonoBinds = mb
+andMonoBinds mb1 mb2 = AndMonoBinds mb1 mb2
+
+andMonoBindList :: [MonoBinds id pat] -> MonoBinds id pat
+andMonoBindList binds = foldr AndMonoBinds EmptyMonoBinds binds
\end{code}
\begin{code}
-instance (NamedThing id, Outputable id, Outputable pat,
- Eq tyvar, Outputable tyvar, Eq uvar, Outputable uvar) =>
- Outputable (MonoBinds tyvar uvar id pat) where
- ppr sty mbind = pprQuote sty (\ sty -> ppr_monobind sty mbind)
+instance (Outputable id, Outputable pat) =>
+ Outputable (MonoBinds id pat) where
+ ppr mbind = ppr_monobind mbind
-ppr_monobind sty EmptyMonoBinds = empty
-ppr_monobind sty (AndMonoBinds binds1 binds2)
- = ($$) (ppr_monobind sty binds1) (ppr_monobind sty binds2)
+ppr_monobind :: (Outputable id, Outputable pat) => MonoBinds id pat -> SDoc
+ppr_monobind EmptyMonoBinds = empty
+ppr_monobind (AndMonoBinds binds1 binds2)
+ = ppr_monobind binds1 $$ ppr_monobind binds2
-ppr_monobind sty (PatMonoBind pat grhss_n_binds locn)
- = hang (ppr sty pat) 4 (pprGRHSsAndBinds sty False grhss_n_binds)
+ppr_monobind (PatMonoBind pat grhss locn)
+ = sep [ppr pat, nest 4 (pprGRHSs False grhss)]
-ppr_monobind sty (FunMonoBind fun inf matches locn)
- = pprMatches sty (False, ppr sty fun) matches
+ppr_monobind (FunMonoBind fun inf matches locn)
+ = pprMatches (False, ppr fun) matches
-- ToDo: print infix if appropriate
-ppr_monobind sty (VarMonoBind name expr)
- = hang (hsep [ppr sty name, equals]) 4 (pprExpr sty expr)
+ppr_monobind (VarMonoBind name expr)
+ = sep [ppr name <+> equals, nest 4 (pprExpr expr)]
-ppr_monobind sty (CoreMonoBind name expr)
- = hang (hsep [ppr sty name, equals]) 4 (ppr sty expr)
+ppr_monobind (CoreMonoBind name expr)
+ = sep [ppr name <+> equals, nest 4 (ppr expr)]
-ppr_monobind sty (AbsBinds tyvars dictvars exports val_binds)
- = ($$) (sep [ptext SLIT("AbsBinds"),
- brackets (interpp'SP sty tyvars),
- brackets (interpp'SP sty dictvars),
- brackets (interpp'SP sty exports)])
- (nest 4 (ppr sty val_binds))
+ppr_monobind (AbsBinds tyvars dictvars exports inlines val_binds)
+ = sep [ptext SLIT("AbsBinds"),
+ brackets (interpp'SP tyvars),
+ brackets (interpp'SP dictvars),
+ brackets (sep (punctuate comma (map ppr exports))),
+ brackets (interpp'SP (nameSetToList inlines))]
+ $$
+ nest 4 (ppr val_binds)
\end{code}
%************************************************************************
(HsType name)
SrcLoc
- | ClassOpSig name -- Selector name
- name -- Default-method name
+ | ClassOpSig name -- Selector name
+ name -- Default-method name (if any)
+ Bool -- True <=> there is an explicit, programmer-supplied
+ -- default declaration in the class decl
(HsType name)
SrcLoc
| SpecSig name -- specialise a function or datatype ...
- (HsType name) -- ... to these types
- (Maybe name) -- ... maybe using this as the code for it
+ (HsType name) -- ... to these types
SrcLoc
- | InlineSig name -- INLINE f
+ | InlineSig name -- INLINE f
+ (Maybe Int) -- phase
SrcLoc
- | DeforestSig name -- Deforest using this function definition
- SrcLoc
+ | NoInlineSig name -- NOINLINE f
+ (Maybe Int) -- phase
+ SrcLoc
+
+ | SpecInstSig (HsType name) -- (Class tys); should be a specialisation of the
+ -- current instance decl
+ SrcLoc
- | MagicUnfoldingSig
- name -- Associate the "name"d function with
- FAST_STRING -- the compiler-builtin unfolding (known
- SrcLoc -- by the String name)
+ | FixSig (FixitySig name) -- Fixity declaration
+
+
+data FixitySig name = FixitySig name Fixity SrcLoc
\end{code}
\begin{code}
-instance (NamedThing name, Outputable name) => Outputable (Sig name) where
- ppr sty sig = pprQuote sty (\ sty -> ppr_sig sty sig)
+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
+
+isFixitySig :: Sig name -> Bool
+isFixitySig (FixSig _) = True
+isFixitySig _ = False
+
+isClassOpSig :: Sig name -> Bool
+isClassOpSig (ClassOpSig _ _ _ _ _) = True
+isClassOpSig _ = False
+
+isPragSig :: Sig name -> Bool
+ -- Identifies pragmas
+isPragSig (SpecSig _ _ _) = True
+isPragSig (InlineSig _ _ _) = True
+isPragSig (NoInlineSig _ _ _) = True
+isPragSig (SpecInstSig _ _) = True
+isPragSig other = False
+\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 sty (Sig var ty _)
- = sep [ppr sty var <+> ptext SLIT("::"),
- nest 4 (ppr sty ty)]
-ppr_sig sty (ClassOpSig var _ ty _)
- = sep [ppr sty (getOccName var) <+> ptext SLIT("::"),
- nest 4 (ppr sty ty)]
+ppr_sig (Sig var ty _)
+ = sep [ppr var <+> dcolon, nest 4 (ppr ty)]
-ppr_sig sty (DeforestSig var _)
- = hsep [text "{-# DEFOREST", ppr sty var, text "#-}"]
+ppr_sig (ClassOpSig var _ _ ty _)
+ = sep [ppr var <+> dcolon, nest 4 (ppr ty)]
-ppr_sig sty (SpecSig var ty using _)
- = sep [ hsep [text "{-# SPECIALIZE", ppr sty var, ptext SLIT("::")],
- nest 4 (hsep [ppr sty ty, pp_using using, text "#-}"])
+ppr_sig (SpecSig var ty _)
+ = sep [ hsep [text "{-# SPECIALIZE", ppr var, dcolon],
+ nest 4 (ppr ty <+> text "#-}")
]
- where
- pp_using Nothing = empty
- pp_using (Just me) = hsep [char '=', ppr sty me]
-ppr_sig sty (InlineSig var _)
- = hsep [text "{-# INLINE", ppr sty var, text "#-}"]
+ppr_sig (InlineSig var phase _)
+ = hsep [text "{-# INLINE", ppr_phase phase, ppr var, text "#-}"]
+
+ppr_sig (NoInlineSig var phase _)
+ = 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_sig sty (MagicUnfoldingSig var str _)
- = hsep [text "{-# MAGIC_UNFOLDING", ppr sty var, ptext str, text "#-}"]
+ppr_phase Nothing = empty
+ppr_phase (Just n) = int n
\end{code}
projects / ghc-hetmet.git / blobdiff