%
+% (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 -fno-warn-incomplete-patterns #-}
+-- 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, DerivDecl(..), LDerivDecl, NewOrData(..),
+ FamilyFlavour(..),
RuleDecl(..), LRuleDecl, RuleBndr(..),
DefaultDecl(..), LDefaultDecl, SpliceDecl(..),
ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
CImportSpec(..), FoType(..),
- ConDecl(..), ResType(..), LConDecl,
- DocDecl(..), LDocDecl, docDeclDoc, DocEntity(..),
- DeprecDecl(..), LDeprecDecl,
+ ConDecl(..), ResType(..), ConDeclField(..), LConDecl,
+ HsConDeclDetails, hsConDeclArgTys,
+ DocDecl(..), LDocDecl, docDeclDoc,
+ WarnDecl(..), LWarnDecl,
HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
tcdName, tyClDeclNames, tyClDeclTyVars,
- isClassDecl, isTFunDecl, isSynDecl, isDataDecl, isKindSigDecl,
- isIdxTyDecl,
+ isClassDecl, isSynDecl, isDataDecl, isTypeDecl, isFamilyDecl,
+ isFamInstDecl,
countTyClDecls,
- conDetailsTys,
instDeclATs,
collectRuleBndrSigTys,
) where
-#include "HsVersions.h"
-
-- friends:
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, HsRecField(..) )
-import HsImpExp ( pprHsVar )
+import HsBinds
+import HsPat
import HsTypes
-import HsDoc ( HsDoc, LHsDoc, ppr_mbDoc )
-import NameSet ( NameSet )
-import CoreSyn ( RuleName )
-import {- Kind parts of -} Type ( Kind, pprKind )
-import BasicTypes ( Activation(..), DeprecTxt )
-import ForeignCall ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
- CExportSpec(..), CLabelString )
+import HsDoc
+import NameSet
+import {- Kind parts of -} Type
+import BasicTypes
+import ForeignCall
-- others:
-import Class ( FunDep, pprFundeps )
+import Class
import Outputable
-import Util ( count )
-import SrcLoc ( Located(..), unLoc, noLoc )
+import Util
+import SrcLoc
import FastString
-import Maybe ( isJust )
+
+import Data.Maybe ( isJust )
\end{code}
%************************************************************************
| SigD (Sig id)
| DefD (DefaultDecl id)
| ForD (ForeignDecl id)
- | DeprecD (DeprecDecl id)
+ | WarningD (WarnDecl id)
| RuleD (RuleDecl id)
| SpliceD (SpliceDecl id)
| DocD (DocDecl id)
hs_defds :: [LDefaultDecl id],
hs_fords :: [LForeignDecl id],
- hs_depds :: [LDeprecDecl id],
+ hs_warnds :: [LWarnDecl id],
hs_ruleds :: [LRuleDecl id],
- hs_docs :: [DocEntity id]
- -- Used to remember the module structure,
- -- which is needed to produce Haddock documentation
+ hs_docs :: [LDocDecl id]
}
emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup a
emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [], hs_derivds = [],
hs_fixds = [], hs_defds = [], hs_fords = [],
- hs_depds = [], hs_ruleds = [],
+ hs_warnds = [], hs_ruleds = [],
hs_valds = error "emptyGroup hs_valds: Can't happen",
hs_docs = [] }
hs_fixds = fixds1,
hs_defds = defds1,
hs_fords = fords1,
- hs_depds = depds1,
+ hs_warnds = warnds1,
hs_ruleds = rulds1,
hs_docs = docs1 }
HsGroup {
hs_fixds = fixds2,
hs_defds = defds2,
hs_fords = fords2,
- hs_depds = depds2,
+ hs_warnds = warnds2,
hs_ruleds = rulds2,
hs_docs = docs2 }
=
hs_fixds = fixds1 ++ fixds2,
hs_defds = defds1 ++ defds2,
hs_fords = fords1 ++ fords2,
- hs_depds = depds1 ++ depds2,
+ hs_warnds = warnds1 ++ warnds2,
hs_ruleds = rulds1 ++ rulds2,
hs_docs = docs1 ++ docs2 }
\end{code}
ppr (ForD fd) = ppr fd
ppr (SigD sd) = ppr sd
ppr (RuleD rd) = ppr rd
- ppr (DeprecD dd) = ppr dd
+ ppr (WarningD wd) = ppr wd
ppr (SpliceD dd) = ppr dd
ppr (DocD doc) = ppr doc
hs_instds = inst_decls,
hs_derivds = deriv_decls,
hs_fixds = fix_decls,
- hs_depds = deprec_decls,
+ hs_warnds = deprec_decls,
hs_fords = foreign_decls,
hs_defds = default_decls,
hs_ruleds = rule_decls })
data SpliceDecl id = SpliceDecl (Located (HsExpr id)) -- Top level splice
instance OutputableBndr name => Outputable (SpliceDecl name) where
- ppr (SpliceDecl e) = ptext SLIT("$") <> parens (pprExpr (unLoc e))
+ ppr (SpliceDecl e) = ptext (sLit "$") <> parens (pprExpr (unLoc e))
\end{code}
\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
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--- Kind signatures of indexed types come in two flavours:
---
--- * kind signatures for type functions: variant `TyFunction' and
---
--- * kind signatures for indexed data types and newtypes : variant `TyData'
--- iff a kind is present in `tcdKindSig' and there are no constructors in
--- `tcdCons'.
+-- 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:
-- 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,
+-- * 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 'tcdVars' are the variables in those patterns. Hence, the arity of
+-- 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'.
--
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
+
tcdTyPats :: Maybe [LHsType name], -- Type patterns
- tcdKindSig:: Maybe Kind, -- Optional kind sig;
- -- (only for the
- -- 'where' form and
- -- indexed type sigs)
+ -- 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
-- are non-empty for the newtype-deriving case
}
- | TyFunction {tcdLName :: Located name, -- type constructor
- tcdTyVars :: [LHsTyVarBndr name], -- type variables
- tcdIso :: Bool, -- injective type?
- tcdKind :: Kind -- result kind
- }
-
| TySynonym { tcdLName :: Located name, -- type constructor
tcdTyVars :: [LHsTyVarBndr name], -- type variables
tcdTyPats :: Maybe [LHsType name], -- Type patterns
- -- 'Nothing' => vanilla
- -- type synonym
+ -- See comments for tcdTyPats in TyData
+ -- 'Nothing' => vanilla type synonym
+
tcdSynRhs :: LHsType name -- synonym expansion
}
tcdSigs :: [LSig name], -- Methods' signatures
tcdMeths :: LHsBinds name, -- Default methods
tcdATs :: [LTyClDecl name], -- Associated types; ie
- -- only 'TyData',
- -- 'TyFunction',
- -- and 'TySynonym'
- tcdDocs :: [DocEntity name] -- Haddock docs
+ -- 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}
-isTFunDecl, isDataDecl, isSynDecl, isClassDecl, isKindSigDecl, isIdxTyDecl ::
+isDataDecl, isTypeDecl, isSynDecl, isClassDecl, isFamilyDecl, isFamInstDecl ::
TyClDecl name -> Bool
--- type function kind signature
-isTFunDecl (TyFunction {}) = True
-isTFunDecl other = False
+-- data/newtype or data/newtype instance declaration
+isDataDecl (TyData {}) = True
+isDataDecl _other = False
+
+-- type or type instance declaration
+isTypeDecl (TySynonym {}) = True
+isTypeDecl _other = False
--- vanilla Haskell type synonym
+-- vanilla Haskell type synonym (ie, not a type instance)
isSynDecl (TySynonym {tcdTyPats = Nothing}) = True
-isSynDecl other = False
+isSynDecl _other = False
--- type equation (of a type function)
-isTEqnDecl (TySynonym {tcdTyPats = Just _}) = True
-isTEqnDecl other = False
+-- type class
+isClassDecl (ClassDecl {}) = True
+isClassDecl _ = False
-isDataDecl (TyData {}) = True
-isDataDecl other = False
+-- type family declaration
+isFamilyDecl (TyFamily {}) = True
+isFamilyDecl _other = False
-isClassDecl (ClassDecl {}) = True
-isClassDecl other = False
-
--- kind signature (for an indexed type)
-isKindSigDecl (TyFunction {} ) = True
-isKindSigDecl (TyData {tcdKindSig = Just _,
- tcdCons = [] }) = True
-isKindSigDecl other = False
-
--- definition of an instance of an indexed type
-isIdxTyDecl tydecl
- | isTEqnDecl tydecl = True
- | isDataDecl tydecl = isJust (tcdTyPats tydecl)
- | otherwise = 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 (TyFunction {tcdLName = name}) = [name]
+tyClDeclNames (TyFamily {tcdLName = name}) = [name]
tyClDeclNames (TySynonym {tcdLName = name}) = [name]
tyClDeclNames (ForeignType {tcdLName = name}) = [name]
tyClDeclNames (TyData {tcdLName = tc_name, tcdCons = cons})
= tc_name : conDeclsNames (map unLoc cons)
-tyClDeclTyVars (TyFunction {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars :: TyClDecl name -> [LHsTyVarBndr name]
+tyClDeclTyVars (TyFamily {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
\begin{code}
countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int, Int)
- -- class, synonym decls, type function signatures,
- -- type function equations, data, newtype
+ -- class, synonym decls, data, newtype, family decls, family instances
countTyClDecls decls
- = (count isClassDecl decls,
- count isSynDecl decls,
- count isTFunDecl decls,
- count isTEqnDecl 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}
=> Outputable (TyClDecl name) where
ppr (ForeignType {tcdLName = ltycon})
- = hsep [ptext SLIT("foreign import type dotnet"), ppr ltycon]
+ = hsep [ptext (sLit "foreign import type dotnet"), ppr ltycon]
- ppr (TyFunction {tcdLName = ltycon, tcdTyVars = tyvars, tcdIso = iso,
- tcdKind = kind})
- = typeMaybeIso <+> pp_decl_head [] ltycon tyvars Nothing <+>
- dcolon <+> pprKind kind
+ ppr (TyFamily {tcdFlavour = flavour, tcdLName = ltycon,
+ tcdTyVars = tyvars, tcdKind = mb_kind})
+ = pp_flavour <+> pp_decl_head [] ltycon tyvars Nothing <+> pp_kind
where
- typeMaybeIso = if iso
- then ptext SLIT("type family iso")
- else ptext SLIT("type family")
+ 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) <+>
+ = hang (ptext (sLit "type") <+>
+ (if isJust typats then ptext (sLit "instance") else empty) <+>
pp_decl_head [] ltycon tyvars typats <+>
equals)
4 (ppr mono_ty)
tcdCons = condecls, tcdDerivs = derivings})
= pp_tydecl (null condecls && isJust mb_sig)
(ppr new_or_data <+>
- (if isJust typats then ptext SLIT("instance") else empty) <+>
+ (if isJust typats then ptext (sLit "instance") else empty) <+>
pp_decl_head (unLoc context) ltycon tyvars typats <+>
ppr_sig mb_sig)
(pp_condecls condecls)
= top_matter
| otherwise -- Laid out
- = sep [hsep [top_matter, ptext SLIT("where {")],
+ = sep [hsep [top_matter, ptext (sLit "where {")],
nest 4 (sep [ sep (map ppr_semi ats)
, sep (map ppr_semi sigs)
, pprLHsBinds methods
, char '}'])]
where
- top_matter = ptext SLIT("class")
+ top_matter = ptext (sLit "class")
<+> pp_decl_head (unLoc context) lclas tyvars Nothing
<+> pprFundeps (map unLoc fds)
ppr_semi decl = ppr decl <> semi
= hsep [ pprHsContext context, ppr thing
, hsep (map (pprParendHsType.unLoc) typats)]
+pp_condecls :: OutputableBndr name => [LConDecl name] -> SDoc
pp_condecls cs@(L _ ConDecl{ con_res = ResTyGADT _ } : _) -- In GADT syntax
- = hang (ptext SLIT("where")) 2 (vcat (map ppr cs))
+ = hang (ptext (sLit "where")) 2 (vcat (map ppr cs))
pp_condecls cs -- In H98 syntax
- = equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
+ = equals <+> sep (punctuate (ptext (sLit " |")) (map ppr cs))
-pp_tydecl True pp_head pp_decl_rhs derivings
+pp_tydecl :: OutputableBndr name => Bool -> SDoc -> SDoc -> Maybe [LHsType name] -> SDoc
+pp_tydecl True pp_head _ _
= 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)]
+ Just ds -> hsep [ptext (sLit "deriving"), parens (interpp'SP ds)]
])
instance Outputable NewOrData where
- ppr NewType = ptext SLIT("newtype")
- ppr DataType = ptext SLIT("data")
+ ppr NewType = ptext (sLit "newtype")
+ ppr DataType = ptext (sLit "data")
\end{code}
, 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 :: (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 | (HsRecField 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 :: 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 (InfixCon t1 t2) = hsep [ppr t1, pprHsInfix 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 (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 fields)))
+pprConDecl (ConDecl con _expl _tvs _cxt (InfixCon _ _) (ResTyGADT _res_ty) _)
+ = pprPanic "pprConDecl" (ppr con)
+ -- In GADT syntax we don't allow infix constructors
+
+
+ppr_fields :: OutputableBndr name => [ConDeclField name] -> SDoc
+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}
%************************************************************************
instance (OutputableBndr name) => Outputable (InstDecl name) where
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) ]
+ = vcat [hsep [ptext (sLit "instance"), ppr inst_ty, ptext (sLit "where")]
+ , nest 4 $ vcat (map ppr ats)
+ , nest 4 $ vcat (map ppr uprags)
+ , nest 4 $ pprLHsBinds binds ]
-- Extract the declarations of associated types from an instance
--
\begin{code}
type LDerivDecl name = Located (DerivDecl name)
-data DerivDecl name
- = DerivDecl (LHsType name) (Located name)
+data DerivDecl name = DerivDecl (LHsType name)
instance (OutputableBndr name) => Outputable (DerivDecl name) where
- ppr (DerivDecl ty n)
- = hsep [ptext SLIT("deriving"), ppr ty, ptext SLIT("for"), ppr n]
+ ppr (DerivDecl ty)
+ = hsep [ptext (sLit "derived instance"), ppr ty]
\end{code}
%************************************************************************
=> Outputable (DefaultDecl name) where
ppr (DefaultDecl tys)
- = ptext SLIT("default") <+> parens (interpp'SP tys)
+ = ptext (sLit "default") <+> parens (interpp'SP tys)
\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) =
- ptext SLIT("dotnet") <+> ppr spec
+ ptext (sLit "dotnet") <+> ppr spec
ppr (CImport cconv safety header lib spec) =
ppr cconv <+> ppr safety <+>
char '"' <> pprCEntity header lib spec <> char '"'
where
pprCEntity header lib (CLabel lbl) =
- ptext SLIT("static") <+> ftext header <+> char '&' <>
+ ptext (sLit "static") <+> ftext header <+> char '&' <>
pprLib lib <> ppr lbl
pprCEntity header lib (CFunction (StaticTarget lbl)) =
- ptext SLIT("static") <+> ftext header <+> char '&' <>
+ ptext (sLit "static") <+> ftext header <+> char '&' <>
pprLib lib <> ppr lbl
- pprCEntity header lib (CFunction (DynamicTarget)) =
- ptext SLIT("dynamic")
- pprCEntity _ _ (CWrapper) = ptext SLIT("wrapper")
+ pprCEntity _ _ (CFunction (DynamicTarget)) =
+ ptext (sLit "dynamic")
+ pprCEntity _ _ (CWrapper) = ptext (sLit "wrapper")
--
pprLib lib | nullFS lib = empty
| otherwise = char '[' <> ppr lib <> char ']'
ppr (CExport (CExportStatic lbl cconv)) =
ppr cconv <+> char '"' <> ppr lbl <> char '"'
ppr (DNExport ) =
- ptext SLIT("dotnet") <+> ptext SLIT("\"<unused>\"")
+ ptext (sLit "dotnet") <+> ptext (sLit "\"<unused>\"")
instance Outputable FoType where
- ppr DNType = ptext SLIT("type dotnet")
+ ppr DNType = ptext (sLit "type dotnet")
\end{code}
collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ ty <- bndrs]
instance OutputableBndr name => Outputable (RuleDecl name) where
- ppr (HsRule name act ns lhs fv_lhs rhs fv_rhs)
+ ppr (HsRule name act ns lhs _fv_lhs rhs _fv_rhs)
= sep [text "{-# RULES" <+> doubleQuotes (ftext name) <+> ppr act,
nest 4 (pp_forall <+> pprExpr (unLoc lhs)),
nest 4 (equals <+> pprExpr (unLoc rhs) <+> text "#-}") ]
\begin{code}
--- source code entities, for representing the module structure
-data DocEntity name
- = DeclEntity name
- | DocEntity (DocDecl name)
-
type LDocDecl name = Located (DocDecl name)
data DocDecl name
instance Outputable (DocDecl name) where
ppr _ = text "<document comment>"
+docDeclDoc :: DocDecl name -> HsDoc name
docDeclDoc (DocCommentNext d) = d
docDeclDoc (DocCommentPrev d) = d
docDeclDoc (DocCommentNamed _ d) = d
We use exported entities for things to deprecate.
\begin{code}
-type LDeprecDecl name = Located (DeprecDecl name)
+type LWarnDecl name = Located (WarnDecl name)
-data DeprecDecl name = Deprecation name DeprecTxt
+data WarnDecl name = Warning name WarningTxt
-instance OutputableBndr name => Outputable (DeprecDecl name) where
- ppr (Deprecation thing txt)
+instance OutputableBndr name => Outputable (WarnDecl name) where
+ ppr (Warning thing txt)
= hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"]
\end{code}