2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[HsDecls]{Abstract syntax: global declarations}
6 Definitions for: @TyDecl@ and @oCnDecl@, @ClassDecl@,
7 @InstDecl@, @DefaultDecl@ and @ForeignDecl@.
11 HsDecl(..), LHsDecl, TyClDecl(..), LTyClDecl,
12 InstDecl(..), LInstDecl, DerivDecl(..), LDerivDecl, NewOrData(..),
13 RuleDecl(..), LRuleDecl, RuleBndr(..),
14 DefaultDecl(..), LDefaultDecl, SpliceDecl(..),
15 ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
16 CImportSpec(..), FoType(..),
17 ConDecl(..), ResType(..), LConDecl,
18 DeprecDecl(..), LDeprecDecl,
19 HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
20 tcdName, tyClDeclNames, tyClDeclTyVars,
21 isClassDecl, isTFunDecl, isSynDecl, isDataDecl, isKindSigDecl,
26 collectRuleBndrSigTys,
29 #include "HsVersions.h"
32 import {-# SOURCE #-} HsExpr( HsExpr, pprExpr )
33 -- Because Expr imports Decls via HsBracket
35 import HsBinds ( HsValBinds(..), HsBind, LHsBinds, plusHsValBinds,
36 Sig(..), LSig, LFixitySig, pprLHsBinds,
37 emptyValBindsIn, emptyValBindsOut )
38 import HsPat ( HsConDetails(..), hsConArgs )
39 import HsImpExp ( pprHsVar )
41 import NameSet ( NameSet )
42 import CoreSyn ( RuleName )
43 import {- Kind parts of -} Type ( Kind, pprKind )
44 import BasicTypes ( Activation(..), DeprecTxt )
45 import ForeignCall ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
46 CExportSpec(..), CLabelString )
49 import Class ( FunDep, pprFundeps )
52 import SrcLoc ( Located(..), unLoc, noLoc )
54 import Maybe ( isJust )
58 %************************************************************************
60 \subsection[HsDecl]{Declarations}
62 %************************************************************************
65 type LHsDecl id = Located (HsDecl id)
70 | DerivD (DerivDecl id)
73 | DefD (DefaultDecl id)
74 | ForD (ForeignDecl id)
75 | DeprecD (DeprecDecl id)
77 | SpliceD (SpliceDecl id)
79 -- NB: all top-level fixity decls are contained EITHER
81 -- OR in the ClassDecls in TyClDs
84 -- a) data constructors
85 -- b) class methods (but they can be also done in the
86 -- signatures of class decls)
87 -- c) imported functions (that have an IfacSig)
90 -- The latter is for class methods only
92 -- A [HsDecl] is categorised into a HsGroup before being
93 -- fed to the renamer.
96 hs_valds :: HsValBinds id,
97 hs_tyclds :: [LTyClDecl id],
98 hs_instds :: [LInstDecl id],
99 hs_derivds :: [LDerivDecl id],
101 hs_fixds :: [LFixitySig id],
102 -- Snaffled out of both top-level fixity signatures,
103 -- and those in class declarations
105 hs_defds :: [LDefaultDecl id],
106 hs_fords :: [LForeignDecl id],
107 hs_depds :: [LDeprecDecl id],
108 hs_ruleds :: [LRuleDecl id]
111 emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup a
112 emptyRdrGroup = emptyGroup { hs_valds = emptyValBindsIn }
113 emptyRnGroup = emptyGroup { hs_valds = emptyValBindsOut }
115 emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [], hs_derivds = [],
116 hs_fixds = [], hs_defds = [], hs_fords = [],
117 hs_depds = [], hs_ruleds = [],
118 hs_valds = error "emptyGroup hs_valds: Can't happen" }
120 appendGroups :: HsGroup a -> HsGroup a -> HsGroup a
123 hs_valds = val_groups1,
126 hs_derivds = derivds1,
133 hs_valds = val_groups2,
136 hs_derivds = derivds2,
144 hs_valds = val_groups1 `plusHsValBinds` val_groups2,
145 hs_tyclds = tyclds1 ++ tyclds2,
146 hs_instds = instds1 ++ instds2,
147 hs_derivds = derivds1 ++ derivds2,
148 hs_fixds = fixds1 ++ fixds2,
149 hs_defds = defds1 ++ defds2,
150 hs_fords = fords1 ++ fords2,
151 hs_depds = depds1 ++ depds2,
152 hs_ruleds = rulds1 ++ rulds2 }
156 instance OutputableBndr name => Outputable (HsDecl name) where
157 ppr (TyClD dcl) = ppr dcl
158 ppr (ValD binds) = ppr binds
159 ppr (DefD def) = ppr def
160 ppr (InstD inst) = ppr inst
161 ppr (DerivD deriv) = ppr deriv
162 ppr (ForD fd) = ppr fd
163 ppr (SigD sd) = ppr sd
164 ppr (RuleD rd) = ppr rd
165 ppr (DeprecD dd) = ppr dd
166 ppr (SpliceD dd) = ppr dd
168 instance OutputableBndr name => Outputable (HsGroup name) where
169 ppr (HsGroup { hs_valds = val_decls,
170 hs_tyclds = tycl_decls,
171 hs_instds = inst_decls,
172 hs_derivds = deriv_decls,
173 hs_fixds = fix_decls,
174 hs_depds = deprec_decls,
175 hs_fords = foreign_decls,
176 hs_defds = default_decls,
177 hs_ruleds = rule_decls })
178 = vcat [ppr_ds fix_decls, ppr_ds default_decls,
179 ppr_ds deprec_decls, ppr_ds rule_decls,
181 ppr_ds tycl_decls, ppr_ds inst_decls,
183 ppr_ds foreign_decls]
186 ppr_ds ds = text "" $$ vcat (map ppr ds)
188 data SpliceDecl id = SpliceDecl (Located (HsExpr id)) -- Top level splice
190 instance OutputableBndr name => Outputable (SpliceDecl name) where
191 ppr (SpliceDecl e) = ptext SLIT("$") <> parens (pprExpr (unLoc e))
195 %************************************************************************
197 \subsection[TyDecl]{@data@, @newtype@ or @type@ (synonym) type declaration}
199 %************************************************************************
201 --------------------------------
203 --------------------------------
205 Here is the story about the implicit names that go with type, class,
206 and instance decls. It's a bit tricky, so pay attention!
208 "Implicit" (or "system") binders
209 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
210 Each data type decl defines
211 a worker name for each constructor
212 to-T and from-T convertors
213 Each class decl defines
214 a tycon for the class
215 a data constructor for that tycon
216 the worker for that constructor
217 a selector for each superclass
219 All have occurrence names that are derived uniquely from their parent
222 None of these get separate definitions in an interface file; they are
223 fully defined by the data or class decl. But they may *occur* in
224 interface files, of course. Any such occurrence must haul in the
225 relevant type or class decl.
228 - Ensure they "point to" the parent data/class decl
229 when loading that decl from an interface file
230 (See RnHiFiles.getSysBinders)
232 - When typechecking the decl, we build the implicit TyCons and Ids.
233 When doing so we look them up in the name cache (RnEnv.lookupSysName),
234 to ensure correct module and provenance is set
236 These are the two places that we have to conjure up the magic derived
237 names. (The actual magic is in OccName.mkWorkerOcc, etc.)
241 - Occurrence name is derived uniquely from the method name
244 - If there is a default method name at all, it's recorded in
245 the ClassOpSig (in HsBinds), in the DefMeth field.
246 (DefMeth is defined in Class.lhs)
248 Source-code class decls and interface-code class decls are treated subtly
249 differently, which has given me a great deal of confusion over the years.
250 Here's the deal. (We distinguish the two cases because source-code decls
251 have (Just binds) in the tcdMeths field, whereas interface decls have Nothing.
253 In *source-code* class declarations:
255 - When parsing, every ClassOpSig gets a DefMeth with a suitable RdrName
256 This is done by RdrHsSyn.mkClassOpSigDM
258 - The renamer renames it to a Name
260 - During typechecking, we generate a binding for each $dm for
261 which there's a programmer-supplied default method:
266 We generate a binding for $dmop1 but not for $dmop2.
267 The Class for Foo has a NoDefMeth for op2 and a DefMeth for op1.
268 The Name for $dmop2 is simply discarded.
270 In *interface-file* class declarations:
271 - When parsing, we see if there's an explicit programmer-supplied default method
272 because there's an '=' sign to indicate it:
274 op1 = :: <type> -- NB the '='
276 We use this info to generate a DefMeth with a suitable RdrName for op1,
277 and a NoDefMeth for op2
278 - The interface file has a separate definition for $dmop1, with unfolding etc.
279 - The renamer renames it to a Name.
280 - The renamer treats $dmop1 as a free variable of the declaration, so that
281 the binding for $dmop1 will be sucked in. (See RnHsSyn.tyClDeclFVs)
282 This doesn't happen for source code class decls, because they *bind* the default method.
286 Each instance declaration gives rise to one dictionary function binding.
288 The type checker makes up new source-code instance declarations
289 (e.g. from 'deriving' or generic default methods --- see
290 TcInstDcls.tcInstDecls1). So we can't generate the names for
291 dictionary functions in advance (we don't know how many we need).
293 On the other hand for interface-file instance declarations, the decl
294 specifies the name of the dictionary function, and it has a binding elsewhere
295 in the interface file:
296 instance {Eq Int} = dEqInt
297 dEqInt :: {Eq Int} <pragma info>
299 So again we treat source code and interface file code slightly differently.
302 - Source code instance decls have a Nothing in the (Maybe name) field
303 (see data InstDecl below)
305 - The typechecker makes up a Local name for the dict fun for any source-code
306 instance decl, whether it comes from a source-code instance decl, or whether
307 the instance decl is derived from some other construct (e.g. 'deriving').
309 - The occurrence name it chooses is derived from the instance decl (just for
310 documentation really) --- e.g. dNumInt. Two dict funs may share a common
311 occurrence name, but will have different uniques. E.g.
312 instance Foo [Int] where ...
313 instance Foo [Bool] where ...
314 These might both be dFooList
316 - The CoreTidy phase externalises the name, and ensures the occurrence name is
317 unique (this isn't special to dict funs). So we'd get dFooList and dFooList1.
319 - We can take this relaxed approach (changing the occurrence name later)
320 because dict fun Ids are not captured in a TyCon or Class (unlike default
321 methods, say). Instead, they are kept separately in the InstEnv. This
322 makes it easy to adjust them after compiling a module. (Once we've finished
323 compiling that module, they don't change any more.)
327 - The instance decl gives the dict fun name, so the InstDecl has a (Just name)
328 in the (Maybe name) field.
330 - RnHsSyn.instDeclFVs treats the dict fun name as free in the decl, so that we
331 suck in the dfun binding
335 -- TyClDecls are precisely the kind of declarations that can
336 -- appear in interface files; or (internally) in GHC's interface
337 -- for a module. That's why (despite the misnomer) IfaceSig and ForeignType
338 -- are both in TyClDecl
340 -- Representation of indexed types
341 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
342 -- Kind signatures of indexed types come in two flavours:
344 -- * kind signatures for type functions: variant `TyFunction' and
346 -- * kind signatures for indexed data types and newtypes : variant `TyData'
347 -- iff a kind is present in `tcdKindSig' and there are no constructors in
350 -- Indexed types are represented by 'TyData' and 'TySynonym' using the field
351 -- 'tcdTyPats::Maybe [LHsType name]', with the following meaning:
353 -- * If it is 'Nothing', we have a *vanilla* data type declaration or type
354 -- synonym declaration and 'tcdVars' contains the type parameters of the
357 -- * If it is 'Just pats', we have the definition of an indexed type Then,
358 -- 'pats' are type patterns for the type-indexes of the type constructor
359 -- and 'tcdVars' are the variables in those patterns. Hence, the arity of
360 -- the indexed type (ie, the number of indexes) is 'length tcdTyPats' and
361 -- *not* 'length tcdVars'.
363 -- In both cases, 'tcdVars' collects all variables we need to quantify over.
365 type LTyClDecl name = Located (TyClDecl name)
369 tcdLName :: Located name,
370 tcdExtName :: Maybe FastString,
374 | TyData { tcdND :: NewOrData,
375 tcdCtxt :: LHsContext name, -- Context
376 tcdLName :: Located name, -- Type constructor
377 tcdTyVars :: [LHsTyVarBndr name], -- Type variables
378 tcdTyPats :: Maybe [LHsType name], -- Type patterns
379 tcdKindSig:: Maybe Kind, -- Optional kind sig;
382 -- indexed type sigs)
384 tcdCons :: [LConDecl name], -- Data constructors
385 -- For data T a = T1 | T2 a the LConDecls all have ResTyH98
386 -- For data T a where { T1 :: T a } the LConDecls all have ResTyGADT
388 tcdDerivs :: Maybe [LHsType name]
389 -- Derivings; Nothing => not specified
390 -- Just [] => derive exactly what is asked
391 -- These "types" must be of form
392 -- forall ab. C ty1 ty2
393 -- Typically the foralls and ty args are empty, but they
394 -- are non-empty for the newtype-deriving case
397 | TyFunction {tcdLName :: Located name, -- type constructor
398 tcdTyVars :: [LHsTyVarBndr name], -- type variables
399 tcdIso :: Bool, -- injective type?
400 tcdKind :: Kind -- result kind
403 | TySynonym { tcdLName :: Located name, -- type constructor
404 tcdTyVars :: [LHsTyVarBndr name], -- type variables
405 tcdTyPats :: Maybe [LHsType name], -- Type patterns
406 -- 'Nothing' => vanilla
408 tcdSynRhs :: LHsType name -- synonym expansion
411 | ClassDecl { tcdCtxt :: LHsContext name, -- Context...
412 tcdLName :: Located name, -- Name of the class
413 tcdTyVars :: [LHsTyVarBndr name], -- Class type variables
414 tcdFDs :: [Located (FunDep name)], -- Functional deps
415 tcdSigs :: [LSig name], -- Methods' signatures
416 tcdMeths :: LHsBinds name, -- Default methods
417 tcdATs :: [LTyClDecl name] -- Associated types; ie
424 = NewType -- "newtype Blah ..."
425 | DataType -- "data Blah ..."
426 deriving( Eq ) -- Needed because Demand derives Eq
432 isTFunDecl, isDataDecl, isSynDecl, isClassDecl, isKindSigDecl, isIdxTyDecl ::
433 TyClDecl name -> Bool
435 -- type function kind signature
436 isTFunDecl (TyFunction {}) = True
437 isTFunDecl other = False
439 -- vanilla Haskell type synonym
440 isSynDecl (TySynonym {tcdTyPats = Nothing}) = True
441 isSynDecl other = False
443 -- type equation (of a type function)
444 isTEqnDecl (TySynonym {tcdTyPats = Just _}) = True
445 isTEqnDecl other = False
447 isDataDecl (TyData {}) = True
448 isDataDecl other = False
450 isClassDecl (ClassDecl {}) = True
451 isClassDecl other = False
453 -- kind signature (for an indexed type)
454 isKindSigDecl (TyFunction {} ) = True
455 isKindSigDecl (TyData {tcdKindSig = Just _,
456 tcdCons = [] }) = True
457 isKindSigDecl other = False
459 -- definition of an instance of an indexed type
461 | isTEqnDecl tydecl = True
462 | isDataDecl tydecl = isJust (tcdTyPats tydecl)
469 tcdName :: TyClDecl name -> name
470 tcdName decl = unLoc (tcdLName decl)
472 tyClDeclNames :: Eq name => TyClDecl name -> [Located name]
473 -- Returns all the *binding* names of the decl, along with their SrcLocs
474 -- The first one is guaranteed to be the name of the decl
475 -- For record fields, the first one counts as the SrcLoc
476 -- We use the equality to filter out duplicate field names
478 tyClDeclNames (TyFunction {tcdLName = name}) = [name]
479 tyClDeclNames (TySynonym {tcdLName = name}) = [name]
480 tyClDeclNames (ForeignType {tcdLName = name}) = [name]
482 tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs, tcdATs = ats})
484 concatMap (tyClDeclNames . unLoc) ats ++ [n | L _ (TypeSig n _) <- sigs]
486 tyClDeclNames (TyData {tcdLName = tc_name, tcdCons = cons})
487 = tc_name : conDeclsNames (map unLoc cons)
489 tyClDeclTyVars (TyFunction {tcdTyVars = tvs}) = tvs
490 tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
491 tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
492 tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
493 tyClDeclTyVars (ForeignType {}) = []
497 countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int, Int)
498 -- class, synonym decls, type function signatures,
499 -- type function equations, data, newtype
501 = (count isClassDecl decls,
502 count isSynDecl decls,
503 count isTFunDecl decls,
504 count isTEqnDecl decls,
505 count isDataTy decls,
508 isDataTy TyData{tcdND=DataType} = True
511 isNewTy TyData{tcdND=NewType} = True
516 instance OutputableBndr name
517 => Outputable (TyClDecl name) where
519 ppr (ForeignType {tcdLName = ltycon})
520 = hsep [ptext SLIT("foreign import type dotnet"), ppr ltycon]
522 ppr (TyFunction {tcdLName = ltycon, tcdTyVars = tyvars, tcdIso = iso,
524 = typeMaybeIso <+> pp_decl_head [] ltycon tyvars Nothing <+>
525 dcolon <+> pprKind kind
527 typeMaybeIso = if iso
528 then ptext SLIT("type family iso")
529 else ptext SLIT("type family")
531 ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdTyPats = typats,
532 tcdSynRhs = mono_ty})
533 = hang (ptext SLIT("type") <+>
534 (if isJust typats then ptext SLIT("instance") else empty) <+>
535 pp_decl_head [] ltycon tyvars typats <+>
539 ppr (TyData {tcdND = new_or_data, tcdCtxt = context, tcdLName = ltycon,
540 tcdTyVars = tyvars, tcdTyPats = typats, tcdKindSig = mb_sig,
541 tcdCons = condecls, tcdDerivs = derivings})
542 = pp_tydecl (null condecls && isJust mb_sig)
544 (if isJust typats then ptext SLIT("instance") else empty) <+>
545 pp_decl_head (unLoc context) ltycon tyvars typats <+>
547 (pp_condecls condecls)
550 ppr_sig Nothing = empty
551 ppr_sig (Just kind) = dcolon <+> pprKind kind
553 ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars,
555 tcdSigs = sigs, tcdMeths = methods, tcdATs = ats})
556 | null sigs && null ats -- No "where" part
559 | otherwise -- Laid out
560 = sep [hsep [top_matter, ptext SLIT("where {")],
561 nest 4 (sep [ sep (map ppr_semi ats)
562 , sep (map ppr_semi sigs)
563 , pprLHsBinds methods
566 top_matter = ptext SLIT("class")
567 <+> pp_decl_head (unLoc context) lclas tyvars Nothing
568 <+> pprFundeps (map unLoc fds)
569 ppr_semi decl = ppr decl <> semi
571 pp_decl_head :: OutputableBndr name
574 -> [LHsTyVarBndr name]
575 -> Maybe [LHsType name]
577 pp_decl_head context thing tyvars Nothing -- no explicit type patterns
578 = hsep [pprHsContext context, ppr thing, interppSP tyvars]
579 pp_decl_head context thing _ (Just typats) -- explicit type patterns
580 = hsep [ pprHsContext context, ppr thing
581 , hsep (map (pprParendHsType.unLoc) typats)]
583 pp_condecls cs@(L _ ConDecl{ con_res = ResTyGADT _ } : _) -- In GADT syntax
584 = hang (ptext SLIT("where")) 2 (vcat (map ppr cs))
585 pp_condecls cs -- In H98 syntax
586 = equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
588 pp_tydecl True pp_head pp_decl_rhs derivings
590 pp_tydecl False pp_head pp_decl_rhs derivings
591 = hang pp_head 4 (sep [
595 Just ds -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]
598 instance Outputable NewOrData where
599 ppr NewType = ptext SLIT("newtype")
600 ppr DataType = ptext SLIT("data")
604 %************************************************************************
606 \subsection[ConDecl]{A data-constructor declaration}
608 %************************************************************************
611 type LConDecl name = Located (ConDecl name)
613 -- data T b = forall a. Eq a => MkT a b
614 -- MkT :: forall b a. Eq a => MkT a b
617 -- MkT1 :: Int -> T Int
619 -- data T = Int `MkT` Int
623 -- Int `MkT` Int :: T Int
627 { con_name :: Located name -- Constructor name; this is used for the
628 -- DataCon itself, and for the user-callable wrapper Id
630 , con_explicit :: HsExplicitForAll -- Is there an user-written forall? (cf. HStypes.HsForAllTy)
632 , con_qvars :: [LHsTyVarBndr name] -- ResTyH98: the constructor's existential type variables
633 -- ResTyGADT: all the constructor's quantified type variables
635 , con_cxt :: LHsContext name -- The context. This *does not* include the
636 -- "stupid theta" which lives only in the TyData decl
638 , con_details :: HsConDetails name (LBangType name) -- The main payload
640 , con_res :: ResType name -- Result type of the constructor
644 = ResTyH98 -- Constructor was declared using Haskell 98 syntax
645 | ResTyGADT (LHsType name) -- Constructor was declared using GADT-style syntax,
646 -- and here is its result type
650 conDeclsNames :: Eq name => [ConDecl name] -> [Located name]
651 -- See tyClDeclNames for what this does
652 -- The function is boringly complicated because of the records
653 -- And since we only have equality, we have to be a little careful
655 = snd (foldl do_one ([], []) cons)
657 do_one (flds_seen, acc) (ConDecl { con_name = lname, con_details = RecCon flds })
658 = (map unLoc new_flds ++ flds_seen, lname : [f | f <- new_flds] ++ acc)
660 new_flds = [ f | (f,_) <- flds, not (unLoc f `elem` flds_seen) ]
662 do_one (flds_seen, acc) c
663 = (flds_seen, (con_name c):acc)
665 conDetailsTys details = map getBangType (hsConArgs details)
670 instance (OutputableBndr name) => Outputable (ConDecl name) where
673 pprConDecl (ConDecl con expl tvs cxt details ResTyH98)
674 = sep [pprHsForAll expl tvs cxt, ppr_details con details]
676 ppr_details con (InfixCon t1 t2) = hsep [ppr t1, pprHsVar con, ppr t2]
677 ppr_details con (PrefixCon tys) = hsep (pprHsVar con : map ppr tys)
678 ppr_details con (RecCon fields) = ppr con <+> ppr_fields fields
680 pprConDecl (ConDecl con expl tvs cxt (PrefixCon arg_tys) (ResTyGADT res_ty))
681 = ppr con <+> dcolon <+>
682 sep [pprHsForAll expl tvs cxt, ppr (foldr mk_fun_ty res_ty arg_tys)]
684 mk_fun_ty a b = noLoc (HsFunTy a b)
685 pprConDecl (ConDecl con expl tvs cxt (RecCon fields) (ResTyGADT res_ty))
686 = sep [pprHsForAll expl tvs cxt, ppr con <+> ppr fields <+> dcolon <+> ppr res_ty]
688 ppr_fields fields = braces (sep (punctuate comma (map ppr_field fields)))
689 ppr_field (n, ty) = ppr n <+> dcolon <+> ppr ty
692 %************************************************************************
694 \subsection[InstDecl]{An instance declaration
696 %************************************************************************
699 type LInstDecl name = Located (InstDecl name)
702 = InstDecl (LHsType name) -- Context => Class Instance-type
703 -- Using a polytype means that the renamer conveniently
704 -- figures out the quantified type variables for us.
706 [LSig name] -- User-supplied pragmatic info
707 [LTyClDecl name]-- Associated types (ie, 'TyData' and
710 instance (OutputableBndr name) => Outputable (InstDecl name) where
712 ppr (InstDecl inst_ty binds uprags ats)
713 = vcat [hsep [ptext SLIT("instance"), ppr inst_ty, ptext SLIT("where")],
716 nest 4 (pprLHsBinds binds) ]
718 -- Extract the declarations of associated types from an instance
720 instDeclATs :: InstDecl name -> [LTyClDecl name]
721 instDeclATs (InstDecl _ _ _ ats) = ats
724 %************************************************************************
726 \subsection[DerivDecl]{A stand-alone instance deriving declaration
728 %************************************************************************
731 type LDerivDecl name = Located (DerivDecl name)
734 = DerivDecl (LHsType name) (Located name)
736 instance (OutputableBndr name) => Outputable (DerivDecl name) where
738 = hsep [ptext SLIT("deriving"), ppr ty, ptext SLIT("for"), ppr n]
741 %************************************************************************
743 \subsection[DefaultDecl]{A @default@ declaration}
745 %************************************************************************
747 There can only be one default declaration per module, but it is hard
748 for the parser to check that; we pass them all through in the abstract
749 syntax, and that restriction must be checked in the front end.
752 type LDefaultDecl name = Located (DefaultDecl name)
754 data DefaultDecl name
755 = DefaultDecl [LHsType name]
757 instance (OutputableBndr name)
758 => Outputable (DefaultDecl name) where
760 ppr (DefaultDecl tys)
761 = ptext SLIT("default") <+> parens (interpp'SP tys)
764 %************************************************************************
766 \subsection{Foreign function interface declaration}
768 %************************************************************************
772 -- foreign declarations are distinguished as to whether they define or use a
775 -- * the Boolean value indicates whether the pre-standard deprecated syntax
778 type LForeignDecl name = Located (ForeignDecl name)
780 data ForeignDecl name
781 = ForeignImport (Located name) (LHsType name) ForeignImport -- defines name
782 | ForeignExport (Located name) (LHsType name) ForeignExport -- uses name
784 -- Specification Of an imported external entity in dependence on the calling
787 data ForeignImport = -- import of a C entity
789 -- * the two strings specifying a header file or library
790 -- may be empty, which indicates the absence of a
791 -- header or object specification (both are not used
792 -- in the case of `CWrapper' and when `CFunction'
793 -- has a dynamic target)
795 -- * the calling convention is irrelevant for code
796 -- generation in the case of `CLabel', but is needed
797 -- for pretty printing
799 -- * `Safety' is irrelevant for `CLabel' and `CWrapper'
801 CImport CCallConv -- ccall or stdcall
802 Safety -- safe or unsafe
803 FastString -- name of C header
804 FastString -- name of library object
805 CImportSpec -- details of the C entity
807 -- import of a .NET function
809 | DNImport DNCallSpec
811 -- details of an external C entity
813 data CImportSpec = CLabel CLabelString -- import address of a C label
814 | CFunction CCallTarget -- static or dynamic function
815 | CWrapper -- wrapper to expose closures
818 -- specification of an externally exported entity in dependence on the calling
821 data ForeignExport = CExport CExportSpec -- contains the calling convention
822 | DNExport -- presently unused
824 -- abstract type imported from .NET
826 data FoType = DNType -- In due course we'll add subtype stuff
827 deriving (Eq) -- Used for equality instance for TyClDecl
830 -- pretty printing of foreign declarations
833 instance OutputableBndr name => Outputable (ForeignDecl name) where
834 ppr (ForeignImport n ty fimport) =
835 ptext SLIT("foreign import") <+> ppr fimport <+>
836 ppr n <+> dcolon <+> ppr ty
837 ppr (ForeignExport n ty fexport) =
838 ptext SLIT("foreign export") <+> ppr fexport <+>
839 ppr n <+> dcolon <+> ppr ty
841 instance Outputable ForeignImport where
842 ppr (DNImport spec) =
843 ptext SLIT("dotnet") <+> ppr spec
844 ppr (CImport cconv safety header lib spec) =
845 ppr cconv <+> ppr safety <+>
846 char '"' <> pprCEntity header lib spec <> char '"'
848 pprCEntity header lib (CLabel lbl) =
849 ptext SLIT("static") <+> ftext header <+> char '&' <>
850 pprLib lib <> ppr lbl
851 pprCEntity header lib (CFunction (StaticTarget lbl)) =
852 ptext SLIT("static") <+> ftext header <+> char '&' <>
853 pprLib lib <> ppr lbl
854 pprCEntity header lib (CFunction (DynamicTarget)) =
855 ptext SLIT("dynamic")
856 pprCEntity _ _ (CWrapper) = ptext SLIT("wrapper")
858 pprLib lib | nullFS lib = empty
859 | otherwise = char '[' <> ppr lib <> char ']'
861 instance Outputable ForeignExport where
862 ppr (CExport (CExportStatic lbl cconv)) =
863 ppr cconv <+> char '"' <> ppr lbl <> char '"'
865 ptext SLIT("dotnet") <+> ptext SLIT("\"<unused>\"")
867 instance Outputable FoType where
868 ppr DNType = ptext SLIT("type dotnet")
872 %************************************************************************
874 \subsection{Transformation rules}
876 %************************************************************************
879 type LRuleDecl name = Located (RuleDecl name)
882 = HsRule -- Source rule
883 RuleName -- Rule name
885 [RuleBndr name] -- Forall'd vars; after typechecking this includes tyvars
886 (Located (HsExpr name)) -- LHS
887 NameSet -- Free-vars from the LHS
888 (Located (HsExpr name)) -- RHS
889 NameSet -- Free-vars from the RHS
892 = RuleBndr (Located name)
893 | RuleBndrSig (Located name) (LHsType name)
895 collectRuleBndrSigTys :: [RuleBndr name] -> [LHsType name]
896 collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ ty <- bndrs]
898 instance OutputableBndr name => Outputable (RuleDecl name) where
899 ppr (HsRule name act ns lhs fv_lhs rhs fv_rhs)
900 = sep [text "{-# RULES" <+> doubleQuotes (ftext name) <+> ppr act,
901 nest 4 (pp_forall <+> pprExpr (unLoc lhs)),
902 nest 4 (equals <+> pprExpr (unLoc rhs) <+> text "#-}") ]
904 pp_forall | null ns = empty
905 | otherwise = text "forall" <+> fsep (map ppr ns) <> dot
907 instance OutputableBndr name => Outputable (RuleBndr name) where
908 ppr (RuleBndr name) = ppr name
909 ppr (RuleBndrSig name ty) = ppr name <> dcolon <> ppr ty
913 %************************************************************************
915 \subsection[DeprecDecl]{Deprecations}
917 %************************************************************************
919 We use exported entities for things to deprecate.
922 type LDeprecDecl name = Located (DeprecDecl name)
924 data DeprecDecl name = Deprecation name DeprecTxt
926 instance OutputableBndr name => Outputable (DeprecDecl name) where
927 ppr (Deprecation thing txt)
928 = hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"]