@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(..),
DefaultDecl(..), LDefaultDecl, SpliceDecl(..),
ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
CImportSpec(..), FoType(..),
- ConDecl(..), ResType(..), LConDecl,
+ ConDecl(..), ResType(..), ConDeclField(..), LConDecl,
+ HsConDeclDetails, hsConDeclArgTys,
DocDecl(..), LDocDecl, docDeclDoc,
- DeprecDecl(..), LDeprecDecl,
+ WarnDecl(..), LWarnDecl,
HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
tcdName, tyClDeclNames, tyClDeclTyVars,
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
| 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 :: [LDocDecl id]
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}
-- 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
tcdSigs :: [LSig name], -- Methods' signatures
tcdMeths :: LHsBinds name, -- Default methods
tcdATs :: [LTyClDecl name], -- Associated types; ie
- -- only 'TyData',
- -- 'TyFunction',
- -- and 'TySynonym'
+ -- only 'TyFamily' and
+ -- 'TySynonym'; the
+ -- latter for defaults
tcdDocs :: [LDocDecl name] -- Haddock docs
}
-- type class
isClassDecl (ClassDecl {}) = True
-isClassDecl other = False
+isClassDecl _ = False
-- type family declaration
isFamilyDecl (TyFamily {}) = True
tyClDeclNames (TyData {tcdLName = tc_name, tcdCons = cons})
= tc_name : conDeclsNames (map unLoc cons)
+tyClDeclTyVars :: TyClDecl name -> [LHsTyVarBndr name]
tyClDeclTyVars (TyFamily {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
=> 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 (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")
+ TypeFamily -> ptext (sLit "type family")
+ DataFamily -> ptext (sLit "data family")
pp_kind = case mb_kind of
Nothing -> empty
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
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
--
instance (OutputableBndr name) => Outputable (DerivDecl name) where
ppr (DerivDecl ty)
- = hsep [ptext SLIT("derived instance"), ppr 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 "#-}") ]
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}