HsExplicitForAll(..),
HsContext, LHsContext,
HsPred(..), LHsPred,
+
+ LBangType, BangType, HsBang(..),
+ getBangType, getBangStrictness,
mkExplicitHsForAllTy, mkImplicitHsForAllTy,
hsTyVarName, hsTyVarNames, replaceTyVarName,
#include "HsVersions.h"
-import TcType ( Type, Kind, liftedTypeKind, eqKind )
-import Type ( {- instance Outputable Kind -}, pprParendKind, pprKind )
+import {-# SOURCE #-} HsExpr ( HsSplice, pprSplice )
+
+import Type ( Type )
+import Kind ( {- instance Outputable Kind -}, Kind,
+ pprParendKind, pprKind, isLiftedTypeKind )
import Name ( Name, mkInternalName )
import OccName ( mkVarOcc )
import BasicTypes ( IPName, Boxity, tupleParens )
noSrcLoc
\end{code}
+%************************************************************************
+%* *
+\subsection{Bang annotations}
+%* *
+%************************************************************************
+
+\begin{code}
+type LBangType name = Located (BangType name)
+type BangType name = HsType name -- Bangs are in the HsType data type
+
+data HsBang = HsNoBang -- Only used as a return value for getBangStrictness,
+ -- never appears on a HsBangTy
+ | HsStrict -- !
+ | HsUnbox -- {-# UNPACK #-} ! (GHC extension, meaning "unbox")
+
+instance Outputable HsBang where
+ ppr (HsNoBang) = empty
+ ppr (HsStrict) = char '!'
+ ppr (HsUnbox) = ptext SLIT("!!")
+
+getBangType :: LHsType a -> LHsType a
+getBangType (L _ (HsBangTy _ ty)) = ty
+getBangType ty = ty
+
+getBangStrictness :: LHsType a -> HsBang
+getBangStrictness (L _ (HsBangTy s _)) = s
+getBangStrictness _ = HsNoBang
+\end{code}
+
%************************************************************************
%* *
| HsTyVar name -- Type variable or type constructor
+ | HsBangTy HsBang (LHsType name) -- Bang-style type annotations
+
| HsAppTy (LHsType name)
(LHsType name)
| HsNumTy Integer -- Generics only
- | HsPredTy (LHsPred name) -- Only used in the type of an instance
+ | HsPredTy (HsPred name) -- Only used in the type of an instance
-- declaration, eg. Eq [a] -> Eq a
-- ^^^^
-- HsPredTy
+ -- Note no need for location info on the
+ -- enclosed HsPred; the one on the type will do
| HsKindSig (LHsType name) -- (ty :: kind)
Kind -- A type with a kind signature
+ | HsSpliceTy (HsSplice name)
+
data HsExplicitForAll = Explicit | Implicit
-----------------------
\begin{code}
splitHsInstDeclTy
- :: Outputable name
+ :: OutputableBndr name
=> HsType name
-> ([LHsTyVarBndr name], HsContext name, name, [LHsType name])
-- Split up an instance decl type, returning the pieces
--- In interface files, the instance declaration head is created
--- by HsTypes.toHsType, which does not guarantee to produce a
--- HsForAllTy. For example, if we had the weird decl
--- instance Foo T => Foo [T]
--- then we'd get the instance type
--- Foo T -> Foo [T]
--- So when colleting the instance context, to be on the safe side
--- we gather predicate arguments
---
--- For source code, the parser ensures the type will have the right shape.
--- (e.g. see ParseUtil.checkInstType)
-
splitHsInstDeclTy inst_ty
= case inst_ty of
- HsForAllTy _ tvs cxt1 tau -- The type vars should have been
- -- computed by now, even if they were implicit
- -> (tvs, unLoc cxt1 ++ cxt2, cls, tys)
- where
- (cxt2, cls, tys) = split_tau (unLoc tau)
-
- other -> ([], cxt2, cls, tys)
- where
- (cxt2, cls, tys) = split_tau inst_ty
-
+ HsParTy (L _ ty) -> splitHsInstDeclTy ty
+ HsForAllTy _ tvs cxt (L _ ty) -> split_tau tvs (unLoc cxt) ty
+ other -> split_tau [] [] other
+ -- The type vars should have been computed by now, even if they were implicit
where
- split_tau (HsFunTy (L _ (HsPredTy p)) ty) = (p:ps, cls, tys)
- where
- (ps, cls, tys) = split_tau (unLoc ty)
- split_tau (HsPredTy (L _ (HsClassP cls tys))) = ([], cls, tys)
- split_tau other = pprPanic "splitHsInstDeclTy" (ppr inst_ty)
+ split_tau tvs cxt (HsPredTy (HsClassP cls tys)) = (tvs, cxt, cls, tys)
+ split_tau tvs cxt (HsParTy (L _ ty)) = split_tau tvs cxt ty
\end{code}
don't change the printing format lightly
\begin{code}
-instance (Outputable name) => Outputable (HsType name) where
+instance (OutputableBndr name) => Outputable (HsType name) where
ppr ty = pprHsType ty
instance (Outputable name) => Outputable (HsTyVarBndr name) where
ppr (UserTyVar name) = ppr name
ppr (KindedTyVar name kind) = pprHsTyVarBndr name kind
-instance Outputable name => Outputable (HsPred name) where
+instance OutputableBndr name => Outputable (HsPred name) where
ppr (HsClassP clas tys) = ppr clas <+> hsep (map (pprParendHsType.unLoc) tys)
ppr (HsIParam n ty) = hsep [ppr n, dcolon, ppr ty]
pprHsTyVarBndr :: Outputable name => name -> Kind -> SDoc
-pprHsTyVarBndr name kind | kind `eqKind` liftedTypeKind = ppr name
- | otherwise = hsep [ppr name, dcolon, pprParendKind kind]
+pprHsTyVarBndr name kind | isLiftedTypeKind kind = ppr name
+ | otherwise = hsep [ppr name, dcolon, pprParendKind kind]
pprHsForAll exp tvs cxt
| show_forall = forall_part <+> pprHsContext (unLoc cxt)
is_explicit = case exp of {Explicit -> True; Implicit -> False}
forall_part = ptext SLIT("forall") <+> interppSP tvs <> dot
-pprHsContext :: (Outputable name) => HsContext name -> SDoc
+pprHsContext :: (OutputableBndr name) => HsContext name -> SDoc
pprHsContext [] = empty
pprHsContext cxt = ppr_hs_context cxt <+> ptext SLIT("=>")
-- printing works more-or-less as for Types
-pprHsType, pprParendHsType :: (Outputable name) => HsType name -> SDoc
+pprHsType, pprParendHsType :: (OutputableBndr name) => HsType name -> SDoc
pprHsType ty = getPprStyle $ \sty -> ppr_mono_ty pREC_TOP (prepare sty ty)
pprParendHsType ty = ppr_mono_ty pREC_CON ty
= maybeParen ctxt_prec pREC_FUN $
sep [pprHsForAll exp tvs ctxt, ppr_mono_lty pREC_TOP ty]
+-- gaw 2004
+ppr_mono_ty ctxt_prec (HsBangTy b ty) = ppr b <> ppr ty
ppr_mono_ty ctxt_prec (HsTyVar name) = ppr name
ppr_mono_ty ctxt_prec (HsFunTy ty1 ty2) = ppr_fun_ty ctxt_prec ty1 ty2
ppr_mono_ty ctxt_prec (HsTupleTy con tys) = tupleParens con (interpp'SP tys)
ppr_mono_ty ctxt_prec (HsPArrTy ty) = pabrackets (ppr_mono_lty pREC_TOP ty)
ppr_mono_ty ctxt_prec (HsPredTy pred) = braces (ppr pred)
ppr_mono_ty ctxt_prec (HsNumTy n) = integer n -- generics only
+ppr_mono_ty ctxt_prec (HsSpliceTy s) = pprSplice s
ppr_mono_ty ctxt_prec (HsAppTy fun_ty arg_ty)
= maybeParen ctxt_prec pREC_CON $