@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(..),
collectRuleBndrSigTys,
) where
-#include "HsVersions.h"
-
-- friends:
import {-# SOURCE #-} HsExpr( HsExpr, pprExpr )
-- Because Expr imports Decls via HsBracket
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}
-- 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}
\end{code}
\begin{code}
-conDeclsNames :: forall name. 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
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]
+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,
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) =
- hang (ptext SLIT("foreign import") <+> ppr fimport <+> ppr n)
+ hang (ptext (sLit "foreign import") <+> ppr fimport <+> ppr n)
2 (dcolon <+> ppr ty)
ppr (ForeignExport n ty fexport) =
- hang (ptext SLIT("foreign export") <+> ppr fexport <+> ppr n)
+ 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