HsTypes: Abstract syntax: user-defined types
\begin{code}
+{-# LANGUAGE DeriveDataTypeable #-}
+
module HsTypes (
HsType(..), LHsType,
HsTyVarBndr(..), LHsTyVarBndr,
- HsExplicitForAll(..),
+ HsExplicitFlag(..),
HsContext, LHsContext,
HsPred(..), LHsPred,
+ HsQuasiQuote(..),
LBangType, BangType, HsBang(..),
getBangType, getBangStrictness,
mkExplicitHsForAllTy, mkImplicitHsForAllTy, hsExplicitTvs,
hsTyVarName, hsTyVarNames, replaceTyVarName,
+ hsTyVarKind, hsTyVarNameKind,
hsLTyVarName, hsLTyVarNames, hsLTyVarLocName, hsLTyVarLocNames,
splitHsInstDeclTy, splitHsFunType,
-- Type place holder
- PostTcType, placeHolderType,
+ PostTcType, placeHolderType, PostTcKind, placeHolderKind,
-- Printing
- pprParendHsType, pprHsForAll, pprHsContext, ppr_hs_context, pprHsTyVarBndr
+ pprParendHsType, pprHsForAll, pprHsContext, ppr_hs_context,
) where
import {-# SOURCE #-} HsExpr ( HsSplice, pprSplice )
+import NameSet( FreeVars )
import Type
import HsDoc
import BasicTypes
import StaticFlags
import Outputable
import FastString
+
+import Data.Data
\end{code}
%************************************************************************
\begin{code}
+type PostTcKind = Kind
type PostTcType = Type -- Used for slots in the abstract syntax
-- where we want to keep slot for a type
-- to be added by the type checker...but
placeHolderType :: PostTcType -- Used before typechecking
placeHolderType = panic "Evaluated the place holder for a PostTcType"
+
+placeHolderKind :: PostTcKind -- Used before typechecking
+placeHolderKind = panic "Evaluated the place holder for a PostTcKind"
+\end{code}
+
+%************************************************************************
+%* *
+ Quasi quotes; used in types and elsewhere
+%* *
+%************************************************************************
+
+\begin{code}
+data HsQuasiQuote id = HsQuasiQuote
+ id -- The quasi-quoter
+ SrcSpan -- The span of the enclosed string
+ FastString -- The enclosed string
+ deriving (Data, Typeable)
+
+instance OutputableBndr id => Outputable (HsQuasiQuote id) where
+ ppr = ppr_qq
+
+ppr_qq :: OutputableBndr id => HsQuasiQuote id -> SDoc
+ppr_qq (HsQuasiQuote quoter _ quote) =
+ char '[' <> ppr quoter <> ptext (sLit "|") <>
+ ppr quote <> ptext (sLit "|]")
\end{code}
+
%************************************************************************
%* *
\subsection{Bang annotations}
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
data HsPred name = HsClassP name [LHsType name] -- class constraint
| HsEqualP (LHsType name) (LHsType name)-- equality constraint
| HsIParam (IPName name) (LHsType name)
+ deriving (Data, Typeable)
type LHsType name = Located (HsType name)
data HsType name
- = HsForAllTy HsExplicitForAll -- Renamer leaves this flag unchanged, to record the way
+ = HsForAllTy HsExplicitFlag -- Renamer leaves this flag unchanged, to record the way
-- the user wrote it originally, so that the printer can
-- print it as the user wrote it
[LHsTyVarBndr name] -- With ImplicitForAll, this is the empty list
-- ^^^^
-- HsPredTy
-- Note no need for location info on the
- -- enclosed HsPred; the one on the type will do
+ -- Enclosed HsPred; the one on the type will do
| HsKindSig (LHsType name) -- (ty :: kind)
Kind -- A type with a kind signature
- | HsSpliceTy (HsSplice name)
+ | HsQuasiQuoteTy (HsQuasiQuote name)
+
+ | HsSpliceTy (HsSplice name)
+ FreeVars -- Variables free in the splice (filled in by renamer)
+ PostTcKind
- | HsDocTy (LHsType name) (LHsDoc name) -- A documented type
+ | HsDocTy (LHsType name) LHsDocString -- A documented type
| HsBangTy HsBang (LHsType name) -- Bang-style type annotations
| HsRecTy [ConDeclField name] -- Only in data type declarations
-data HsExplicitForAll = Explicit | Implicit
-
+ | HsCoreTy Type -- An escape hatch for tunnelling a *closed*
+ -- Core Type through HsSyn.
+
+ deriving (Data, Typeable)
+data HsExplicitFlag = Explicit | Implicit deriving (Data, Typeable)
data ConDeclField name -- Record fields have Haddoc docs on them
= ConDeclField { cd_fld_name :: Located name,
cd_fld_type :: LBangType name,
- cd_fld_doc :: Maybe (LHsDoc name) }
-
+ cd_fld_doc :: Maybe LHsDocString }
+ deriving (Data, Typeable)
-----------------------
-- Combine adjacent for-alls.
mkImplicitHsForAllTy ctxt ty = mkHsForAllTy Implicit [] ctxt ty
mkExplicitHsForAllTy tvs ctxt ty = mkHsForAllTy Explicit tvs ctxt ty
-mkHsForAllTy :: HsExplicitForAll -> [LHsTyVarBndr name] -> LHsContext name -> LHsType name -> HsType name
+mkHsForAllTy :: HsExplicitFlag -> [LHsTyVarBndr name] -> LHsContext name -> LHsType name -> HsType name
-- Smart constructor for HsForAllTy
mkHsForAllTy exp tvs (L _ []) ty = mk_forall_ty exp tvs ty
mkHsForAllTy exp tvs ctxt ty = HsForAllTy exp tvs ctxt ty
-- mk_forall_ty makes a pure for-all type (no context)
-mk_forall_ty :: HsExplicitForAll -> [LHsTyVarBndr name] -> LHsType name -> HsType name
+mk_forall_ty :: HsExplicitFlag -> [LHsTyVarBndr name] -> LHsType name -> HsType name
mk_forall_ty exp tvs (L _ (HsParTy ty)) = mk_forall_ty exp tvs ty
mk_forall_ty exp1 tvs1 (L _ (HsForAllTy exp2 tvs2 ctxt ty)) = mkHsForAllTy (exp1 `plus` exp2) (tvs1 ++ tvs2) ctxt ty
mk_forall_ty exp tvs ty = HsForAllTy exp tvs (L noSrcSpan []) ty
-- (see the sigtype production in Parser.y.pp)
-- so that (forall. ty) isn't implicitly quantified
-plus :: HsExplicitForAll -> HsExplicitForAll -> HsExplicitForAll
+plus :: HsExplicitFlag -> HsExplicitFlag -> HsExplicitFlag
Implicit `plus` Implicit = Implicit
_ `plus` _ = Explicit
type LHsTyVarBndr name = Located (HsTyVarBndr name)
data HsTyVarBndr name
- = UserTyVar name
- | KindedTyVar name Kind
- -- *** NOTA BENE *** A "monotype" in a pragma can have
- -- for-alls in it, (mostly to do with dictionaries). These
- -- must be explicitly Kinded.
+ = UserTyVar -- No explicit kinding
+ name -- See Note [Printing KindedTyVars]
+ PostTcKind
+
+ | KindedTyVar
+ name
+ Kind
+ -- *** NOTA BENE *** A "monotype" in a pragma can have
+ -- for-alls in it, (mostly to do with dictionaries). These
+ -- must be explicitly Kinded.
+ deriving (Data, Typeable)
hsTyVarName :: HsTyVarBndr name -> name
-hsTyVarName (UserTyVar n) = n
+hsTyVarName (UserTyVar n _) = n
hsTyVarName (KindedTyVar n _) = n
+hsTyVarKind :: HsTyVarBndr name -> Kind
+hsTyVarKind (UserTyVar _ k) = k
+hsTyVarKind (KindedTyVar _ k) = k
+
+hsTyVarNameKind :: HsTyVarBndr name -> (name, Kind)
+hsTyVarNameKind (UserTyVar n k) = (n,k)
+hsTyVarNameKind (KindedTyVar n k) = (n,k)
+
hsLTyVarName :: LHsTyVarBndr name -> name
hsLTyVarName = hsTyVarName . unLoc
hsLTyVarLocNames = map hsLTyVarLocName
replaceTyVarName :: HsTyVarBndr name1 -> name2 -> HsTyVarBndr name2
-replaceTyVarName (UserTyVar _) n' = UserTyVar n'
+replaceTyVarName (UserTyVar _ k) n' = UserTyVar n' k
replaceTyVarName (KindedTyVar _ k) n' = KindedTyVar n' k
\end{code}
ppr ty = pprHsType ty
instance (Outputable name) => Outputable (HsTyVarBndr name) where
- ppr (UserTyVar name) = ppr name
- ppr (KindedTyVar name kind) = pprHsTyVarBndr name kind
+ ppr (UserTyVar name _) = ppr name
+ ppr (KindedTyVar name kind) = hsep [ppr name, dcolon, pprParendKind kind]
instance OutputableBndr name => Outputable (HsPred name) where
ppr (HsClassP clas tys) = ppr clas <+> hsep (map pprLHsType tys)
pprLHsType :: OutputableBndr name => LHsType name -> SDoc
pprLHsType = pprParendHsType . unLoc
-pprHsTyVarBndr :: Outputable name => name -> Kind -> SDoc
-pprHsTyVarBndr name kind | isLiftedTypeKind kind = ppr name
- | otherwise = hsep [ppr name, dcolon, pprParendKind kind]
-
-pprHsForAll :: OutputableBndr name => HsExplicitForAll -> [LHsTyVarBndr name] -> LHsContext name -> SDoc
+pprHsForAll :: OutputableBndr name => HsExplicitFlag -> [LHsTyVarBndr name] -> LHsContext name -> SDoc
pprHsForAll exp tvs cxt
| show_forall = forall_part <+> pprHsContext (unLoc cxt)
| otherwise = pprHsContext (unLoc cxt)
forall_part = ptext (sLit "forall") <+> interppSP tvs <> dot
pprHsContext :: (OutputableBndr name) => HsContext name -> SDoc
-pprHsContext [] = empty
-pprHsContext cxt = ppr_hs_context cxt <+> ptext (sLit "=>")
+pprHsContext [] = empty
+pprHsContext [L _ pred]
+ | noParenHsPred pred = ppr pred <+> ptext (sLit "=>")
+pprHsContext cxt = ppr_hs_context cxt <+> ptext (sLit "=>")
+
+noParenHsPred :: HsPred name -> Bool
+-- c.f. TypeRep.noParenPred
+noParenHsPred (HsClassP {}) = True
+noParenHsPred (HsEqualP {}) = True
+noParenHsPred (HsIParam {}) = False
ppr_hs_context :: (OutputableBndr name) => HsContext name -> SDoc
ppr_hs_context [] = empty
= ppr n <+> dcolon <+> ppr ty <+> ppr_mbDoc doc
\end{code}
+Note [Printing KindedTyVars]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Trac #3830 reminded me that we should really only print the kind
+signature on a KindedTyVar if the kind signature was put there by the
+programmer. During kind inference GHC now adds a PostTcKind to UserTyVars,
+rather than converting to KindedTyVars as before.
+
+(As it happens, the message in #3830 comes out a different way now,
+and the problem doesn't show up; but having the flag on a KindedTyVar
+seems like the Right Thing anyway.)
+
\begin{code}
pREC_TOP, pREC_FUN, pREC_OP, pREC_CON :: Int
pREC_TOP = 0 -- type in ParseIface.y
= maybeParen ctxt_prec pREC_FUN $
sep [pprHsForAll exp tvs ctxt, ppr_mono_lty pREC_TOP ty]
-ppr_mono_ty _ (HsBangTy b ty) = ppr b <> ppr ty
-ppr_mono_ty _ (HsRecTy flds) = pprConDeclFields flds
-ppr_mono_ty _ (HsTyVar name) = ppr name
-ppr_mono_ty ctxt_prec (HsFunTy ty1 ty2) = ppr_fun_ty ctxt_prec ty1 ty2
-ppr_mono_ty _ (HsTupleTy con tys) = tupleParens con (interpp'SP tys)
-ppr_mono_ty _ (HsKindSig ty kind) = parens (ppr_mono_lty pREC_TOP ty <+> dcolon <+> pprKind kind)
-ppr_mono_ty _ (HsListTy ty) = brackets (ppr_mono_lty pREC_TOP ty)
-ppr_mono_ty _ (HsPArrTy ty) = pabrackets (ppr_mono_lty pREC_TOP ty)
-ppr_mono_ty _ (HsPredTy pred) = ppr pred
-ppr_mono_ty _ (HsNumTy n) = integer n -- generics only
-ppr_mono_ty _ (HsSpliceTy s) = pprSplice s
+ppr_mono_ty _ (HsBangTy b ty) = ppr b <> ppr ty
+ppr_mono_ty _ (HsQuasiQuoteTy qq) = ppr qq
+ppr_mono_ty _ (HsRecTy flds) = pprConDeclFields flds
+ppr_mono_ty _ (HsTyVar name) = ppr name
+ppr_mono_ty prec (HsFunTy ty1 ty2) = ppr_fun_ty prec ty1 ty2
+ppr_mono_ty _ (HsTupleTy con tys) = tupleParens con (interpp'SP tys)
+ppr_mono_ty _ (HsKindSig ty kind) = parens (ppr_mono_lty pREC_TOP ty <+> dcolon <+> pprKind kind)
+ppr_mono_ty _ (HsListTy ty) = brackets (ppr_mono_lty pREC_TOP ty)
+ppr_mono_ty _ (HsPArrTy ty) = pabrackets (ppr_mono_lty pREC_TOP ty)
+ppr_mono_ty _ (HsPredTy pred) = ppr pred
+ppr_mono_ty _ (HsNumTy n) = integer n -- generics only
+ppr_mono_ty _ (HsSpliceTy s _ _) = pprSplice s
+ppr_mono_ty _ (HsCoreTy ty) = ppr ty
ppr_mono_ty ctxt_prec (HsAppTy fun_ty arg_ty)
= maybeParen ctxt_prec pREC_CON $
projects / ghc-hetmet.git / blobdiff