%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
-\section[HsDecls]{Abstract syntax: global declarations}
+
+HsDecls: Abstract syntax: global declarations
Definitions for: @TyDecl@ and @oCnDecl@, @ClassDecl@,
@InstDecl@, @DefaultDecl@ and @ForeignDecl@.
\begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module HsDecls (
HsDecl(..), LHsDecl, TyClDecl(..), LTyClDecl,
- InstDecl(..), LInstDecl, NewOrData(..),
+ InstDecl(..), LInstDecl, DerivDecl(..), LDerivDecl, NewOrData(..),
+ FamilyFlavour(..),
RuleDecl(..), LRuleDecl, RuleBndr(..),
DefaultDecl(..), LDefaultDecl, SpliceDecl(..),
ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
CImportSpec(..), FoType(..),
- ConDecl(..), ResType(..), LConDecl,
+ ConDecl(..), ResType(..), ConDeclField(..), LConDecl,
+ HsConDeclDetails, hsConDeclArgTys,
+ DocDecl(..), LDocDecl, docDeclDoc,
DeprecDecl(..), LDeprecDecl,
HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
tcdName, tyClDeclNames, tyClDeclTyVars,
- isClassDecl, isSynDecl, isDataDecl,
+ isClassDecl, isSynDecl, isDataDecl, isTypeDecl, isFamilyDecl,
+ isFamInstDecl,
countTyClDecls,
- conDetailsTys,
+ instDeclATs,
collectRuleBndrSigTys,
) where
import {-# SOURCE #-} HsExpr( HsExpr, pprExpr )
-- Because Expr imports Decls via HsBracket
-import HsBinds ( HsValBinds(..), HsBind, LHsBinds, plusHsValBinds,
- Sig(..), LSig, LFixitySig, pprLHsBinds,
- emptyValBindsIn, emptyValBindsOut )
-import HsPat ( HsConDetails(..), hsConArgs )
-import HsImpExp ( pprHsVar )
+import HsBinds
+import HsPat
+import HsImpExp
import HsTypes
-import NameSet ( NameSet )
-import HscTypes ( DeprecTxt )
-import CoreSyn ( RuleName )
-import Kind ( Kind, pprKind )
-import BasicTypes ( Activation(..) )
-import ForeignCall ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
- CExportSpec(..), CLabelString )
+import HsDoc
+import NameSet
+import CoreSyn
+import {- Kind parts of -} Type
+import BasicTypes
+import ForeignCall
-- others:
-import FunDeps ( pprFundeps )
-import Class ( FunDep )
+import Class
import Outputable
-import Util ( count )
-import SrcLoc ( Located(..), unLoc, noLoc )
+import Util
+import SrcLoc
import FastString
-\end{code}
+import Data.Maybe ( isJust )
+\end{code}
%************************************************************************
%* *
data HsDecl id
= TyClD (TyClDecl id)
| InstD (InstDecl id)
+ | DerivD (DerivDecl id)
| ValD (HsBind id)
| SigD (Sig id)
| DefD (DefaultDecl id)
| DeprecD (DeprecDecl id)
| RuleD (RuleDecl id)
| SpliceD (SpliceDecl id)
+ | DocD (DocDecl id)
+
-- NB: all top-level fixity decls are contained EITHER
-- EITHER SigDs
hs_valds :: HsValBinds id,
hs_tyclds :: [LTyClDecl id],
hs_instds :: [LInstDecl id],
+ hs_derivds :: [LDerivDecl id],
hs_fixds :: [LFixitySig id],
-- Snaffled out of both top-level fixity signatures,
hs_defds :: [LDefaultDecl id],
hs_fords :: [LForeignDecl id],
hs_depds :: [LDeprecDecl id],
- hs_ruleds :: [LRuleDecl id]
+ hs_ruleds :: [LRuleDecl id],
+
+ hs_docs :: [LDocDecl id]
}
emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup a
emptyRdrGroup = emptyGroup { hs_valds = emptyValBindsIn }
emptyRnGroup = emptyGroup { hs_valds = emptyValBindsOut }
-emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [],
+emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [], hs_derivds = [],
hs_fixds = [], hs_defds = [], hs_fords = [],
hs_depds = [], hs_ruleds = [],
- hs_valds = error "emptyGroup hs_valds: Can't happen" }
+ hs_valds = error "emptyGroup hs_valds: Can't happen",
+ hs_docs = [] }
appendGroups :: HsGroup a -> HsGroup a -> HsGroup a
appendGroups
hs_valds = val_groups1,
hs_tyclds = tyclds1,
hs_instds = instds1,
+ hs_derivds = derivds1,
hs_fixds = fixds1,
hs_defds = defds1,
hs_fords = fords1,
hs_depds = depds1,
- hs_ruleds = rulds1 }
+ hs_ruleds = rulds1,
+ hs_docs = docs1 }
HsGroup {
hs_valds = val_groups2,
hs_tyclds = tyclds2,
hs_instds = instds2,
+ hs_derivds = derivds2,
hs_fixds = fixds2,
hs_defds = defds2,
hs_fords = fords2,
hs_depds = depds2,
- hs_ruleds = rulds2 }
+ hs_ruleds = rulds2,
+ hs_docs = docs2 }
=
HsGroup {
hs_valds = val_groups1 `plusHsValBinds` val_groups2,
hs_tyclds = tyclds1 ++ tyclds2,
hs_instds = instds1 ++ instds2,
+ hs_derivds = derivds1 ++ derivds2,
hs_fixds = fixds1 ++ fixds2,
hs_defds = defds1 ++ defds2,
hs_fords = fords1 ++ fords2,
hs_depds = depds1 ++ depds2,
- hs_ruleds = rulds1 ++ rulds2 }
+ hs_ruleds = rulds1 ++ rulds2,
+ hs_docs = docs1 ++ docs2 }
\end{code}
\begin{code}
instance OutputableBndr name => Outputable (HsDecl name) where
- ppr (TyClD dcl) = ppr dcl
- ppr (ValD binds) = ppr binds
- ppr (DefD def) = ppr def
- ppr (InstD inst) = ppr inst
- ppr (ForD fd) = ppr fd
- ppr (SigD sd) = ppr sd
- ppr (RuleD rd) = ppr rd
- ppr (DeprecD dd) = ppr dd
- ppr (SpliceD dd) = ppr dd
+ ppr (TyClD dcl) = ppr dcl
+ ppr (ValD binds) = ppr binds
+ ppr (DefD def) = ppr def
+ ppr (InstD inst) = ppr inst
+ ppr (DerivD deriv) = ppr deriv
+ ppr (ForD fd) = ppr fd
+ ppr (SigD sd) = ppr sd
+ ppr (RuleD rd) = ppr rd
+ ppr (DeprecD dd) = ppr dd
+ ppr (SpliceD dd) = ppr dd
+ ppr (DocD doc) = ppr doc
instance OutputableBndr name => Outputable (HsGroup name) where
ppr (HsGroup { hs_valds = val_decls,
hs_tyclds = tycl_decls,
hs_instds = inst_decls,
+ hs_derivds = deriv_decls,
hs_fixds = fix_decls,
hs_depds = deprec_decls,
hs_fords = foreign_decls,
ppr_ds deprec_decls, ppr_ds rule_decls,
ppr val_decls,
ppr_ds tycl_decls, ppr_ds inst_decls,
+ ppr_ds deriv_decls,
ppr_ds foreign_decls]
where
ppr_ds [] = empty
\begin{code}
--- TyClDecls are precisely the kind of declarations that can
--- appear in interface files; or (internally) in GHC's interface
--- for a module. That's why (despite the misnomer) IfaceSig and ForeignType
--- are both in TyClDecl
+-- Representation of indexed types
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Family kind signatures are represented by the variant `TyFamily'. It
+-- covers "type family", "newtype family", and "data family" declarations,
+-- distinguished by the value of the field `tcdFlavour'.
+--
+-- Indexed types are represented by 'TyData' and 'TySynonym' using the field
+-- 'tcdTyPats::Maybe [LHsType name]', with the following meaning:
+--
+-- * If it is 'Nothing', we have a *vanilla* data type declaration or type
+-- synonym declaration and 'tcdVars' contains the type parameters of the
+-- type constructor.
+--
+-- * If it is 'Just pats', we have the definition of an indexed type. Then,
+-- 'pats' are type patterns for the type-indexes of the type constructor
+-- and 'tcdTyVars' are the variables in those patterns. Hence, the arity of
+-- the indexed type (ie, the number of indexes) is 'length tcdTyPats' and
+-- *not* 'length tcdVars'.
+--
+-- In both cases, 'tcdVars' collects all variables we need to quantify over.
type LTyClDecl name = Located (TyClDecl name)
tcdLName :: Located name,
tcdExtName :: Maybe FastString,
tcdFoType :: FoType
- }
+ }
+
+ -- type/data/newtype family T :: *->*
+ | TyFamily { tcdFlavour:: FamilyFlavour, -- type, new, or data
+ tcdLName :: Located name, -- type constructor
+ tcdTyVars :: [LHsTyVarBndr name], -- type variables
+ tcdKind :: Maybe Kind -- result kind
+ }
+ -- Declares a data type or newtype, giving its construcors
+ -- data/newtype T a = <constrs>
+ -- data/newtype instance T [a] = <constrs>
| TyData { tcdND :: NewOrData,
tcdCtxt :: LHsContext name, -- Context
tcdLName :: Located name, -- Type constructor
+
tcdTyVars :: [LHsTyVarBndr name], -- Type variables
- tcdKindSig :: Maybe Kind, -- Optional kind sig;
- -- (only for the 'where' form)
+
+ tcdTyPats :: Maybe [LHsType name], -- Type patterns
+ -- Just [t1..tn] for data instance T t1..tn = ...
+ -- in this case tcdTyVars = fv( tcdTyPats )
+ -- Nothing for everything else
+
+ tcdKindSig:: Maybe Kind, -- Optional kind sig
+ -- (Just k) for a GADT-style 'data', or 'data
+ -- instance' decl with explicit kind sig
tcdCons :: [LConDecl name], -- Data constructors
- -- For data T a = T1 | T2 a the LConDecls all have ResTyH98
- -- For data T a where { T1 :: T a } the LConDecls all have ResTyGADT
+ -- For data T a = T1 | T2 a
+ -- the LConDecls all have ResTyH98
+ -- For data T a where { T1 :: T a }
+ -- the LConDecls all have ResTyGADT
tcdDerivs :: Maybe [LHsType name]
-- Derivings; Nothing => not specified
| TySynonym { tcdLName :: Located name, -- type constructor
tcdTyVars :: [LHsTyVarBndr name], -- type variables
+ tcdTyPats :: Maybe [LHsType name], -- Type patterns
+ -- See comments for tcdTyPats in TyData
+ -- 'Nothing' => vanilla type synonym
+
tcdSynRhs :: LHsType name -- synonym expansion
}
tcdTyVars :: [LHsTyVarBndr name], -- Class type variables
tcdFDs :: [Located (FunDep name)], -- Functional deps
tcdSigs :: [LSig name], -- Methods' signatures
- tcdMeths :: LHsBinds name -- Default methods
+ tcdMeths :: LHsBinds name, -- Default methods
+ tcdATs :: [LTyClDecl name], -- Associated types; ie
+ -- only 'TyFamily' and
+ -- 'TySynonym'; the
+ -- latter for defaults
+ tcdDocs :: [LDocDecl name] -- Haddock docs
}
data NewOrData
- = NewType -- "newtype Blah ..."
- | DataType -- "data Blah ..."
- deriving( Eq ) -- Needed because Demand derives Eq
+ = NewType -- "newtype Blah ..."
+ | DataType -- "data Blah ..."
+ deriving( Eq ) -- Needed because Demand derives Eq
+
+data FamilyFlavour
+ = TypeFamily -- "type family ..."
+ | DataFamily -- "data family ..."
\end{code}
Simple classifiers
\begin{code}
-isDataDecl, isSynDecl, isClassDecl :: TyClDecl name -> Bool
-
-isSynDecl (TySynonym {}) = True
-isSynDecl other = False
+isDataDecl, isTypeDecl, isSynDecl, isClassDecl, isFamilyDecl, isFamInstDecl ::
+ TyClDecl name -> Bool
+-- data/newtype or data/newtype instance declaration
isDataDecl (TyData {}) = True
-isDataDecl other = False
+isDataDecl _other = False
+
+-- type or type instance declaration
+isTypeDecl (TySynonym {}) = True
+isTypeDecl _other = False
+-- vanilla Haskell type synonym (ie, not a type instance)
+isSynDecl (TySynonym {tcdTyPats = Nothing}) = True
+isSynDecl _other = False
+
+-- type class
isClassDecl (ClassDecl {}) = True
isClassDecl other = False
+
+-- type family declaration
+isFamilyDecl (TyFamily {}) = True
+isFamilyDecl _other = False
+
+-- family instance (types, newtypes, and data types)
+isFamInstDecl tydecl
+ | isTypeDecl tydecl
+ || isDataDecl tydecl = isJust (tcdTyPats tydecl)
+ | otherwise = False
\end{code}
Dealing with names
-- For record fields, the first one counts as the SrcLoc
-- We use the equality to filter out duplicate field names
-tyClDeclNames (TySynonym {tcdLName = name}) = [name]
-tyClDeclNames (ForeignType {tcdLName = name}) = [name]
+tyClDeclNames (TyFamily {tcdLName = name}) = [name]
+tyClDeclNames (TySynonym {tcdLName = name}) = [name]
+tyClDeclNames (ForeignType {tcdLName = name}) = [name]
-tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs})
- = cls_name : [n | L _ (TypeSig n _) <- sigs]
+tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs, tcdATs = ats})
+ = cls_name :
+ concatMap (tyClDeclNames . unLoc) ats ++ [n | L _ (TypeSig n _) <- sigs]
tyClDeclNames (TyData {tcdLName = tc_name, tcdCons = cons})
= tc_name : conDeclsNames (map unLoc cons)
-tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (ForeignType {}) = []
+tyClDeclTyVars (TyFamily {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (ForeignType {}) = []
\end{code}
\begin{code}
-countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int)
- -- class, data, newtype, synonym decls
+countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int, Int)
+ -- class, synonym decls, data, newtype, family decls, family instances
countTyClDecls decls
- = (count isClassDecl decls,
- count isSynDecl decls,
- count isDataTy decls,
- count isNewTy decls)
+ = (count isClassDecl decls,
+ count isSynDecl decls, -- excluding...
+ count isDataTy decls, -- ...family...
+ count isNewTy decls, -- ...instances
+ count isFamilyDecl decls,
+ count isFamInstDecl decls)
where
- isDataTy TyData{tcdND=DataType} = True
- isDataTy _ = False
+ isDataTy TyData{tcdND = DataType, tcdTyPats = Nothing} = True
+ isDataTy _ = False
- isNewTy TyData{tcdND=NewType} = True
- isNewTy _ = False
+ isNewTy TyData{tcdND = NewType, tcdTyPats = Nothing} = True
+ isNewTy _ = False
\end{code}
\begin{code}
ppr (ForeignType {tcdLName = ltycon})
= hsep [ptext SLIT("foreign import type dotnet"), ppr ltycon]
- ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdSynRhs = mono_ty})
- = hang (ptext SLIT("type") <+> pp_decl_head [] ltycon tyvars <+> equals)
+ ppr (TyFamily {tcdFlavour = flavour, tcdLName = ltycon,
+ tcdTyVars = tyvars, tcdKind = mb_kind})
+ = pp_flavour <+> pp_decl_head [] ltycon tyvars Nothing <+> pp_kind
+ where
+ pp_flavour = case flavour of
+ TypeFamily -> ptext SLIT("type family")
+ DataFamily -> ptext SLIT("data family")
+
+ pp_kind = case mb_kind of
+ Nothing -> empty
+ Just kind -> dcolon <+> pprKind kind
+
+ ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdTyPats = typats,
+ tcdSynRhs = mono_ty})
+ = hang (ptext SLIT("type") <+>
+ (if isJust typats then ptext SLIT("instance") else empty) <+>
+ pp_decl_head [] ltycon tyvars typats <+>
+ equals)
4 (ppr mono_ty)
ppr (TyData {tcdND = new_or_data, tcdCtxt = context, tcdLName = ltycon,
- tcdTyVars = tyvars, tcdKindSig = mb_sig, tcdCons = condecls,
- tcdDerivs = derivings})
- = pp_tydecl (ppr new_or_data <+> pp_decl_head (unLoc context) ltycon tyvars <+> ppr_sig mb_sig)
+ tcdTyVars = tyvars, tcdTyPats = typats, tcdKindSig = mb_sig,
+ tcdCons = condecls, tcdDerivs = derivings})
+ = pp_tydecl (null condecls && isJust mb_sig)
+ (ppr new_or_data <+>
+ (if isJust typats then ptext SLIT("instance") else empty) <+>
+ pp_decl_head (unLoc context) ltycon tyvars typats <+>
+ ppr_sig mb_sig)
(pp_condecls condecls)
derivings
where
ppr_sig Nothing = empty
ppr_sig (Just kind) = dcolon <+> pprKind kind
- ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars, tcdFDs = fds,
- tcdSigs = sigs, tcdMeths = methods})
- | null sigs -- No "where" part
+ ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars,
+ tcdFDs = fds,
+ tcdSigs = sigs, tcdMeths = methods, tcdATs = ats})
+ | null sigs && null ats -- No "where" part
= top_matter
| otherwise -- Laid out
= sep [hsep [top_matter, ptext SLIT("where {")],
- nest 4 (sep [sep (map ppr_sig sigs), pprLHsBinds methods, char '}'])]
+ nest 4 (sep [ sep (map ppr_semi ats)
+ , sep (map ppr_semi sigs)
+ , pprLHsBinds methods
+ , char '}'])]
where
- top_matter = ptext SLIT("class") <+> pp_decl_head (unLoc context) lclas tyvars <+> pprFundeps (map unLoc fds)
- ppr_sig sig = ppr sig <> semi
+ top_matter = ptext SLIT("class")
+ <+> pp_decl_head (unLoc context) lclas tyvars Nothing
+ <+> pprFundeps (map unLoc fds)
+ ppr_semi decl = ppr decl <> semi
pp_decl_head :: OutputableBndr name
=> HsContext name
-> Located name
-> [LHsTyVarBndr name]
+ -> Maybe [LHsType name]
-> SDoc
-pp_decl_head context thing tyvars
+pp_decl_head context thing tyvars Nothing -- no explicit type patterns
= hsep [pprHsContext context, ppr thing, interppSP tyvars]
+pp_decl_head context thing _ (Just typats) -- explicit type patterns
+ = hsep [ pprHsContext context, ppr thing
+ , hsep (map (pprParendHsType.unLoc) typats)]
+
pp_condecls cs@(L _ ConDecl{ con_res = ResTyGADT _ } : _) -- In GADT syntax
= hang (ptext SLIT("where")) 2 (vcat (map ppr cs))
pp_condecls cs -- In H98 syntax
= equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
-pp_tydecl pp_head pp_decl_rhs derivings
+pp_tydecl True pp_head pp_decl_rhs derivings
+ = pp_head
+pp_tydecl False pp_head pp_decl_rhs derivings
= hang pp_head 4 (sep [
- pp_decl_rhs,
- case derivings of
- Nothing -> empty
- Just ds -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]
+ pp_decl_rhs,
+ case derivings of
+ Nothing -> empty
+ Just ds -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]
])
instance Outputable NewOrData where
, con_cxt :: LHsContext name -- The context. This *does not* include the
-- "stupid theta" which lives only in the TyData decl
- , con_details :: HsConDetails name (LBangType name) -- The main payload
+ , con_details :: HsConDeclDetails name -- The main payload
, con_res :: ResType name -- Result type of the constructor
+
+ , con_doc :: Maybe (LHsDoc name) -- A possible Haddock comment
}
+type HsConDeclDetails name = HsConDetails (LBangType name) [ConDeclField name]
+
+hsConDeclArgTys :: HsConDeclDetails name -> [LBangType name]
+hsConDeclArgTys (PrefixCon tys) = tys
+hsConDeclArgTys (InfixCon ty1 ty2) = [ty1,ty2]
+hsConDeclArgTys (RecCon flds) = map cd_fld_type flds
+
+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) }
+
data ResType name
= ResTyH98 -- Constructor was declared using Haskell 98 syntax
| ResTyGADT (LHsType name) -- Constructor was declared using GADT-style syntax,
\end{code}
\begin{code}
-conDeclsNames :: Eq name => [ConDecl name] -> [Located name]
+conDeclsNames :: forall name. Eq name => [ConDecl name] -> [Located name]
-- See tyClDeclNames for what this does
-- The function is boringly complicated because of the records
-- And since we only have equality, we have to be a little careful
= snd (foldl do_one ([], []) cons)
where
do_one (flds_seen, acc) (ConDecl { con_name = lname, con_details = RecCon flds })
- = (map unLoc new_flds ++ flds_seen, lname : [f | f <- new_flds] ++ acc)
+ = (map unLoc new_flds ++ flds_seen, lname : new_flds ++ acc)
where
- new_flds = [ f | (f,_) <- flds, not (unLoc f `elem` flds_seen) ]
+ new_flds = filterOut (\f -> unLoc f `elem` flds_seen)
+ (map cd_fld_name flds)
do_one (flds_seen, acc) c
= (flds_seen, (con_name c):acc)
-
-conDetailsTys details = map getBangType (hsConArgs details)
\end{code}
instance (OutputableBndr name) => Outputable (ConDecl name) where
ppr = pprConDecl
-pprConDecl (ConDecl con expl tvs cxt details ResTyH98)
- = sep [pprHsForAll expl tvs cxt, ppr_details con details]
+pprConDecl :: OutputableBndr name => ConDecl name -> SDoc
+pprConDecl (ConDecl con expl tvs cxt details ResTyH98 doc)
+ = sep [ppr_mbDoc doc, pprHsForAll expl tvs cxt, ppr_details con details]
where
ppr_details con (InfixCon t1 t2) = hsep [ppr t1, pprHsVar con, ppr t2]
ppr_details con (PrefixCon tys) = hsep (pprHsVar con : map ppr tys)
ppr_details con (RecCon fields) = ppr con <+> ppr_fields fields
-pprConDecl (ConDecl con expl tvs cxt (PrefixCon arg_tys) (ResTyGADT res_ty))
+pprConDecl (ConDecl con expl tvs cxt (PrefixCon arg_tys) (ResTyGADT res_ty) _)
= ppr con <+> dcolon <+>
sep [pprHsForAll expl tvs cxt, ppr (foldr mk_fun_ty res_ty arg_tys)]
where
mk_fun_ty a b = noLoc (HsFunTy a b)
-pprConDecl (ConDecl con expl tvs cxt (RecCon fields) (ResTyGADT res_ty))
- = sep [pprHsForAll expl tvs cxt, ppr con <+> ppr fields <+> dcolon <+> ppr res_ty]
-ppr_fields fields = braces (sep (punctuate comma (map ppr_field fields)))
-ppr_field (n, ty) = ppr n <+> dcolon <+> ppr ty
+pprConDecl (ConDecl con expl tvs cxt (RecCon fields) (ResTyGADT res_ty) _)
+ = sep [pprHsForAll expl tvs cxt, ppr con <+> ppr_fields fields <+> dcolon <+> ppr res_ty]
+
+ppr_fields fields = braces (sep (punctuate comma (map ppr_fld fields)))
+ where
+ ppr_fld (ConDeclField { cd_fld_name = n, cd_fld_type = ty,
+ cd_fld_doc = doc })
+ = ppr n <+> dcolon <+> ppr ty <+> ppr_mbDoc doc
\end{code}
%************************************************************************
-- Using a polytype means that the renamer conveniently
-- figures out the quantified type variables for us.
(LHsBinds name)
- [LSig name] -- User-supplied pragmatic info
+ [LSig name] -- User-supplied pragmatic info
+ [LTyClDecl name]-- Associated types (ie, 'TyData' and
+ -- 'TySynonym' only)
instance (OutputableBndr name) => Outputable (InstDecl name) where
- ppr (InstDecl inst_ty binds uprags)
+ ppr (InstDecl inst_ty binds uprags ats)
= vcat [hsep [ptext SLIT("instance"), ppr inst_ty, ptext SLIT("where")],
+ nest 4 (ppr ats),
nest 4 (ppr uprags),
nest 4 (pprLHsBinds binds) ]
+
+-- Extract the declarations of associated types from an instance
+--
+instDeclATs :: InstDecl name -> [LTyClDecl name]
+instDeclATs (InstDecl _ _ _ ats) = ats
+\end{code}
+
+%************************************************************************
+%* *
+\subsection[DerivDecl]{A stand-alone instance deriving declaration
+%* *
+%************************************************************************
+
+\begin{code}
+type LDerivDecl name = Located (DerivDecl name)
+
+data DerivDecl name = DerivDecl (LHsType name)
+
+instance (OutputableBndr name) => Outputable (DerivDecl name) where
+ ppr (DerivDecl ty)
+ = hsep [ptext SLIT("derived instance"), ppr ty]
\end{code}
%************************************************************************
instance OutputableBndr name => Outputable (ForeignDecl name) where
ppr (ForeignImport n ty fimport) =
- ptext SLIT("foreign import") <+> ppr fimport <+>
- ppr n <+> dcolon <+> ppr ty
+ hang (ptext SLIT("foreign import") <+> ppr fimport <+> ppr n)
+ 2 (dcolon <+> ppr ty)
ppr (ForeignExport n ty fexport) =
- ptext SLIT("foreign export") <+> ppr fexport <+>
- ppr n <+> dcolon <+> ppr ty
+ hang (ptext SLIT("foreign export") <+> ppr fexport <+> ppr n)
+ 2 (dcolon <+> ppr ty)
instance Outputable ForeignImport where
ppr (DNImport spec) =
ppr (RuleBndrSig name ty) = ppr name <> dcolon <> ppr ty
\end{code}
+%************************************************************************
+%* *
+\subsection[DocDecl]{Document comments}
+%* *
+%************************************************************************
+
+\begin{code}
+
+type LDocDecl name = Located (DocDecl name)
+
+data DocDecl name
+ = DocCommentNext (HsDoc name)
+ | DocCommentPrev (HsDoc name)
+ | DocCommentNamed String (HsDoc name)
+ | DocGroup Int (HsDoc name)
+
+-- Okay, I need to reconstruct the document comments, but for now:
+instance Outputable (DocDecl name) where
+ ppr _ = text "<document comment>"
+
+docDeclDoc (DocCommentNext d) = d
+docDeclDoc (DocCommentPrev d) = d
+docDeclDoc (DocCommentNamed _ d) = d
+docDeclDoc (DocGroup _ d) = d
+
+\end{code}
%************************************************************************
%* *
projects / ghc-hetmet.git / blobdiff