\begin{code}
module HsDecls (
- HsDecl(..), TyClDecl(..), InstDecl(..), RuleDecl(..), RuleBndr(..),
- DefaultDecl(..), HsGroup(..), SpliceDecl(..),
- ForeignDecl(..), ForeignImport(..), ForeignExport(..),
+ HsDecl(..), LHsDecl, TyClDecl(..), LTyClDecl,
+ InstDecl(..), LInstDecl, NewOrData(..),
+ RuleDecl(..), LRuleDecl, RuleBndr(..),
+ DefaultDecl(..), LDefaultDecl, SpliceDecl(..),
+ ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..),
CImportSpec(..), FoType(..),
- ConDecl(..),
- BangType(..), HsBang(..), getBangType, getBangStrictness, unbangedType,
- DeprecDecl(..),
- tyClDeclName, tyClDeclNames, tyClDeclTyVars,
+ ConDecl(..), ResType(..), LConDecl,
+ DeprecDecl(..), LDeprecDecl,
+ HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
+ tcdName, tyClDeclNames, tyClDeclTyVars,
isClassDecl, isSynDecl, isDataDecl,
countTyClDecls,
conDetailsTys,
import {-# SOURCE #-} HsExpr( HsExpr, pprExpr )
-- Because Expr imports Decls via HsBracket
-import HsBinds ( HsBinds, MonoBinds, Sig(..), FixitySig )
+import HsBinds ( HsValBinds(..), HsBind, LHsBinds, plusHsValBinds,
+ Sig(..), LSig, LFixitySig, pprLHsBinds,
+ emptyValBindsIn, emptyValBindsOut )
import HsPat ( HsConDetails(..), hsConArgs )
import HsImpExp ( pprHsVar )
import HsTypes
+import NameSet ( NameSet )
import HscTypes ( DeprecTxt )
import CoreSyn ( RuleName )
-import BasicTypes ( NewOrData(..), Activation(..) )
+import Kind ( Kind, pprKind )
+import BasicTypes ( Activation(..) )
import ForeignCall ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
- CExportSpec(..))
+ CExportSpec(..), CLabelString )
-- others:
import FunDeps ( pprFundeps )
import Class ( FunDep )
-import CStrings ( CLabelString )
import Outputable
import Util ( count )
-import SrcLoc ( SrcLoc )
+import SrcLoc ( Located(..), unLoc, noLoc )
import FastString
\end{code}
%************************************************************************
\begin{code}
+type LHsDecl id = Located (HsDecl id)
+
data HsDecl id
= TyClD (TyClDecl id)
| InstD (InstDecl id)
- | ValD (MonoBinds id)
+ | ValD (HsBind id)
| SigD (Sig id)
| DefD (DefaultDecl id)
| ForD (ForeignDecl id)
-- fed to the renamer.
data HsGroup id
= HsGroup {
- hs_valds :: HsBinds id,
- -- Before the renamer, this is a single big MonoBinds,
- -- with all the bindings, and all the signatures.
- -- The renamer does dependency analysis, using ThenBinds
- -- to give the structure
-
- hs_tyclds :: [TyClDecl id],
- hs_instds :: [InstDecl id],
+ hs_valds :: HsValBinds id,
+ hs_tyclds :: [LTyClDecl id],
+ hs_instds :: [LInstDecl id],
- hs_fixds :: [FixitySig id],
+ hs_fixds :: [LFixitySig id],
-- Snaffled out of both top-level fixity signatures,
-- and those in class declarations
- hs_defds :: [DefaultDecl id],
- hs_fords :: [ForeignDecl id],
- hs_depds :: [DeprecDecl id],
- hs_ruleds :: [RuleDecl id]
+ hs_defds :: [LDefaultDecl id],
+ hs_fords :: [LForeignDecl id],
+ hs_depds :: [LDeprecDecl id],
+ hs_ruleds :: [LRuleDecl id]
}
+
+emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup a
+emptyRdrGroup = emptyGroup { hs_valds = emptyValBindsIn }
+emptyRnGroup = emptyGroup { hs_valds = emptyValBindsOut }
+
+emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [],
+ hs_fixds = [], hs_defds = [], hs_fords = [],
+ hs_depds = [], hs_ruleds = [],
+ hs_valds = error "emptyGroup hs_valds: Can't happen" }
+
+appendGroups :: HsGroup a -> HsGroup a -> HsGroup a
+appendGroups
+ HsGroup {
+ hs_valds = val_groups1,
+ hs_tyclds = tyclds1,
+ hs_instds = instds1,
+ hs_fixds = fixds1,
+ hs_defds = defds1,
+ hs_fords = fords1,
+ hs_depds = depds1,
+ hs_ruleds = rulds1 }
+ HsGroup {
+ hs_valds = val_groups2,
+ hs_tyclds = tyclds2,
+ hs_instds = instds2,
+ hs_fixds = fixds2,
+ hs_defds = defds2,
+ hs_fords = fords2,
+ hs_depds = depds2,
+ hs_ruleds = rulds2 }
+ =
+ HsGroup {
+ hs_valds = val_groups1 `plusHsValBinds` val_groups2,
+ hs_tyclds = tyclds1 ++ tyclds2,
+ hs_instds = instds1 ++ instds2,
+ hs_fixds = fixds1 ++ fixds2,
+ hs_defds = defds1 ++ defds2,
+ hs_fords = fords1 ++ fords2,
+ hs_depds = depds1 ++ depds2,
+ hs_ruleds = rulds1 ++ rulds2 }
\end{code}
\begin{code}
ppr_ds [] = empty
ppr_ds ds = text "" $$ vcat (map ppr ds)
-data SpliceDecl id = SpliceDecl (HsExpr id) SrcLoc -- Top level splice
+data SpliceDecl id = SpliceDecl (Located (HsExpr id)) -- Top level splice
instance OutputableBndr name => Outputable (SpliceDecl name) where
- ppr (SpliceDecl e _) = ptext SLIT("$") <> parens (pprExpr e)
+ ppr (SpliceDecl e) = ptext SLIT("$") <> parens (pprExpr (unLoc e))
\end{code}
THE NAMING STORY
--------------------------------
-Here is the story about the implicit names that go with type, class, and instance
-decls. It's a bit tricky, so pay attention!
+Here is the story about the implicit names that go with type, class,
+and instance decls. It's a bit tricky, so pay attention!
"Implicit" (or "system") binders
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
the worker for that constructor
a selector for each superclass
-All have occurrence names that are derived uniquely from their parent declaration.
+All have occurrence names that are derived uniquely from their parent
+declaration.
None of these get separate definitions in an interface file; they are
fully defined by the data or class decl. But they may *occur* in
-- for a module. That's why (despite the misnomer) IfaceSig and ForeignType
-- are both in TyClDecl
+type LTyClDecl name = Located (TyClDecl name)
+
data TyClDecl name
- = ForeignType { tcdName :: name,
- tcdExtName :: Maybe FastString,
- tcdFoType :: FoType,
- tcdLoc :: SrcLoc }
+ = ForeignType {
+ tcdLName :: Located name,
+ tcdExtName :: Maybe FastString,
+ tcdFoType :: FoType
+ }
| TyData { tcdND :: NewOrData,
- tcdCtxt :: HsContext name, -- Context
- tcdName :: name, -- Type constructor
- tcdTyVars :: [HsTyVarBndr name], -- Type variables
- tcdCons :: [ConDecl name], -- Data constructors
- tcdDerivs :: Maybe (HsContext name), -- Derivings; Nothing => not specified
- -- Just [] => derive exactly what is asked
- tcdLoc :: SrcLoc
+ 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)
+
+ 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
+
+ tcdDerivs :: Maybe [LHsType name]
+ -- Derivings; Nothing => not specified
+ -- Just [] => derive exactly what is asked
+ -- These "types" must be of form
+ -- forall ab. C ty1 ty2
+ -- Typically the foralls and ty args are empty, but they
+ -- are non-empty for the newtype-deriving case
}
- | TySynonym { tcdName :: name, -- type constructor
- tcdTyVars :: [HsTyVarBndr name], -- type variables
- tcdSynRhs :: HsType name, -- synonym expansion
- tcdLoc :: SrcLoc
+ | TySynonym { tcdLName :: Located name, -- type constructor
+ tcdTyVars :: [LHsTyVarBndr name], -- type variables
+ tcdSynRhs :: LHsType name -- synonym expansion
}
- | ClassDecl { tcdCtxt :: HsContext name, -- Context...
- tcdName :: name, -- Name of the class
- tcdTyVars :: [HsTyVarBndr name], -- The class type variables
- tcdFDs :: [FunDep name], -- Functional dependencies
- tcdSigs :: [Sig name], -- Methods' signatures
- tcdMeths :: MonoBinds name, -- Default methods
- tcdLoc :: SrcLoc
+ | ClassDecl { tcdCtxt :: LHsContext name, -- Context...
+ tcdLName :: Located name, -- Name of the class
+ tcdTyVars :: [LHsTyVarBndr name], -- Class type variables
+ tcdFDs :: [Located (FunDep name)], -- Functional deps
+ tcdSigs :: [LSig name], -- Methods' signatures
+ tcdMeths :: LHsBinds name -- Default methods
}
+
+data NewOrData
+ = NewType -- "newtype Blah ..."
+ | DataType -- "data Blah ..."
+ deriving( Eq ) -- Needed because Demand derives Eq
\end{code}
Simple classifiers
Dealing with names
\begin{code}
---------------------------------
-tyClDeclName :: TyClDecl name -> name
-tyClDeclName tycl_decl = tcdName tycl_decl
+tcdName :: TyClDecl name -> name
+tcdName decl = unLoc (tcdLName decl)
---------------------------------
-tyClDeclNames :: Eq name => TyClDecl name -> [(name, SrcLoc)]
+tyClDeclNames :: Eq name => TyClDecl name -> [Located name]
-- Returns all the *binding* names of the decl, along with their SrcLocs
-- The first one is guaranteed to be the name of the decl
-- For record fields, the first one counts as the SrcLoc
-- We use the equality to filter out duplicate field names
-tyClDeclNames (TySynonym {tcdName = name, tcdLoc = loc}) = [(name,loc)]
-tyClDeclNames (ForeignType {tcdName = name, tcdLoc = loc}) = [(name,loc)]
+tyClDeclNames (TySynonym {tcdLName = name}) = [name]
+tyClDeclNames (ForeignType {tcdLName = name}) = [name]
-tyClDeclNames (ClassDecl {tcdName = cls_name, tcdSigs = sigs, tcdLoc = loc})
- = (cls_name,loc) : [(n,loc) | Sig n _ loc <- sigs]
+tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs})
+ = cls_name : [n | L _ (TypeSig n _) <- sigs]
-tyClDeclNames (TyData {tcdName = tc_name, tcdCons = cons, tcdLoc = loc})
- = (tc_name,loc) : conDeclsNames cons
+tyClDeclNames (TyData {tcdLName = tc_name, tcdCons = cons})
+ = tc_name : conDeclsNames (map unLoc cons)
tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
instance OutputableBndr name
=> Outputable (TyClDecl name) where
- ppr (ForeignType {tcdName = tycon})
- = hsep [ptext SLIT("foreign import type dotnet"), ppr tycon]
+ ppr (ForeignType {tcdLName = ltycon})
+ = hsep [ptext SLIT("foreign import type dotnet"), ppr ltycon]
- ppr (TySynonym {tcdName = tycon, tcdTyVars = tyvars, tcdSynRhs = mono_ty})
- = hang (ptext SLIT("type") <+> pp_decl_head [] tycon tyvars <+> equals)
+ ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdSynRhs = mono_ty})
+ = hang (ptext SLIT("type") <+> pp_decl_head [] ltycon tyvars <+> equals)
4 (ppr mono_ty)
- ppr (TyData {tcdND = new_or_data, tcdCtxt = context, tcdName = tycon,
- tcdTyVars = tyvars, tcdCons = condecls,
+ 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 context tycon tyvars)
+ = pp_tydecl (ppr new_or_data <+> pp_decl_head (unLoc context) ltycon tyvars <+> ppr_sig mb_sig)
(pp_condecls condecls)
derivings
+ where
+ ppr_sig Nothing = empty
+ ppr_sig (Just kind) = dcolon <+> pprKind kind
- ppr (ClassDecl {tcdCtxt = context, tcdName = clas, tcdTyVars = tyvars, tcdFDs = fds,
+ ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars, tcdFDs = fds,
tcdSigs = sigs, tcdMeths = methods})
| null sigs -- No "where" part
= top_matter
= sep [hsep [top_matter, ptext SLIT("where {")],
nest 4 (sep [sep (map ppr_sig sigs), ppr methods, char '}'])]
where
- top_matter = ptext SLIT("class") <+> pp_decl_head context clas tyvars <+> pprFundeps fds
+ top_matter = ptext SLIT("class") <+> pp_decl_head (unLoc context) lclas tyvars <+> pprFundeps (map unLoc fds)
ppr_sig sig = ppr sig <> semi
-pp_decl_head :: OutputableBndr name => HsContext name -> name -> [HsTyVarBndr name] -> SDoc
-pp_decl_head context thing tyvars = hsep [pprHsContext context, ppr thing, interppSP tyvars]
-
-pp_condecls cs = equals <+> sep (punctuate (ptext SLIT(" |")) (map ppr cs))
+pp_decl_head :: OutputableBndr name
+ => HsContext name
+ -> Located name
+ -> [LHsTyVarBndr name]
+ -> SDoc
+pp_decl_head context thing tyvars
+ = hsep [pprHsContext context, ppr thing, interppSP tyvars]
+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
= hang pp_head 4 (sep [
pp_decl_rhs,
case derivings of
Nothing -> empty
- Just ds -> hsep [ptext SLIT("deriving"), ppr_hs_context 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")
\end{code}
%************************************************************************
\begin{code}
+type LConDecl name = Located (ConDecl name)
+
+-- data T b = forall a. Eq a => MkT a b
+-- MkT :: forall b a. Eq a => MkT a b
+
+-- data T b where
+-- MkT1 :: Int -> T Int
+
+-- data T = Int `MkT` Int
+-- | MkT2
+
+-- data T a where
+-- Int `MkT` Int :: T Int
+
data ConDecl name
- = ConDecl name -- Constructor name; this is used for the
- -- DataCon itself, and for the user-callable wrapper Id
+ = ConDecl
+ { con_name :: Located name -- Constructor name; this is used for the
+ -- DataCon itself, and for the user-callable wrapper Id
+
+ , con_explicit :: HsExplicitForAll -- Is there an user-written forall? (cf. HStypes.HsForAllTy)
+
+ , con_qvars :: [LHsTyVarBndr name] -- ResTyH98: the constructor's existential type variables
+ -- ResTyGADT: all the constructor's quantified type variables
+
+ , con_cxt :: LHsContext name -- The context. This *does not* include the
+ -- "stupid theta" which lives only in the TyData decl
- [HsTyVarBndr name] -- Existentially quantified type variables
- (HsContext name) -- ...and context
- -- If both are empty then there are no existentials
+ , con_details :: HsConDetails name (LBangType name) -- The main payload
- (HsConDetails name (BangType name))
- SrcLoc
+ , con_res :: ResType name -- Result type of the constructor
+ }
+
+data ResType name
+ = ResTyH98 -- Constructor was declared using Haskell 98 syntax
+ | ResTyGADT (LHsType name) -- Constructor was declared using GADT-style syntax,
+ -- and here is its result type
\end{code}
\begin{code}
-conDeclsNames :: Eq name => [ConDecl name] -> [(name,SrcLoc)]
+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
conDeclsNames cons
= snd (foldl do_one ([], []) cons)
where
- do_one (flds_seen, acc) (ConDecl name _ _ (RecCon flds) loc)
- = (new_flds ++ flds_seen, (name,loc) : [(f,loc) | f <- new_flds] ++ acc)
+ 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)
where
- new_flds = [ f | (f,_) <- flds, not (f `elem` flds_seen) ]
+ new_flds = [ f | (f,_) <- flds, not (unLoc f `elem` flds_seen) ]
- do_one (flds_seen, acc) (ConDecl name _ _ _ loc)
- = (flds_seen, (name,loc):acc)
+ do_one (flds_seen, acc) c
+ = (flds_seen, (con_name c):acc)
conDetailsTys details = map getBangType (hsConArgs details)
\end{code}
-\begin{code}
-data BangType name = BangType HsBang (HsType name)
-
-data HsBang = HsNoBang
- | HsStrict -- !
- | HsUnbox -- !! (GHC extension, meaning "unbox")
-
-getBangType (BangType _ ty) = ty
-getBangStrictness (BangType s _) = s
-
-unbangedType ty = BangType HsNoBang ty
-\end{code}
\begin{code}
instance (OutputableBndr name) => Outputable (ConDecl name) where
- ppr (ConDecl con tvs cxt con_details loc)
- = sep [pprHsForAll Explicit tvs cxt, ppr_con_details con con_details]
+ ppr = pprConDecl
-ppr_con_details con (InfixCon ty1 ty2)
- = hsep [ppr ty1, ppr con, ppr ty2]
-
--- ConDecls generated by MkIface.ifaceTyThing always have a PrefixCon, even
--- if the constructor is an infix one. This is because in an interface file
--- we don't distinguish between the two. Hence when printing these for the
--- user, we need to parenthesise infix constructor names.
-ppr_con_details con (PrefixCon tys)
- = hsep (pprHsVar con : map ppr tys)
+pprConDecl (ConDecl con expl tvs cxt details ResTyH98)
+ = sep [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
-ppr_con_details con (RecCon fields)
- = ppr con <+> braces (sep (punctuate comma (map ppr_field fields)))
+pprConDecl (ConDecl con expl tvs cxt details (ResTyGADT res_ty))
+ = sep [pprHsForAll expl tvs cxt, ppr con <+> ppr_details details]
where
- ppr_field (n, ty) = ppr n <+> dcolon <+> ppr ty
+ ppr_details (PrefixCon arg_tys) = dcolon <+> ppr (foldr mk_fun_ty res_ty arg_tys)
+ ppr_details (RecCon fields) = ppr fields <+> dcolon <+> ppr res_ty
-instance OutputableBndr name => Outputable (BangType name) where
- ppr (BangType is_strict ty)
- = bang <> pprParendHsType ty
- where
- bang = case is_strict of
- HsNoBang -> empty
- HsStrict -> char '!'
- HsUnbox -> ptext SLIT("!!")
-\end{code}
+ mk_fun_ty a b = noLoc (HsFunTy a b)
+ppr_fields fields = braces (sep (punctuate comma (map ppr_field fields)))
+ppr_field (n, ty) = ppr n <+> dcolon <+> ppr ty
+\end{code}
%************************************************************************
%* *
%************************************************************************
\begin{code}
+type LInstDecl name = Located (InstDecl name)
+
data InstDecl name
- = InstDecl (HsType name) -- Context => Class Instance-type
+ = InstDecl (LHsType name) -- Context => Class Instance-type
-- Using a polytype means that the renamer conveniently
-- figures out the quantified type variables for us.
- (MonoBinds name)
- [Sig name] -- User-supplied pragmatic info
- SrcLoc
+ (LHsBinds name)
+ [LSig name] -- User-supplied pragmatic info
instance (OutputableBndr name) => Outputable (InstDecl name) where
- ppr (InstDecl inst_ty binds uprags src_loc)
+ ppr (InstDecl inst_ty binds uprags)
= vcat [hsep [ptext SLIT("instance"), ppr inst_ty, ptext SLIT("where")],
nest 4 (ppr uprags),
- nest 4 (ppr binds) ]
+ nest 4 (pprLHsBinds binds) ]
\end{code}
%************************************************************************
syntax, and that restriction must be checked in the front end.
\begin{code}
+type LDefaultDecl name = Located (DefaultDecl name)
+
data DefaultDecl name
- = DefaultDecl [HsType name]
- SrcLoc
+ = DefaultDecl [LHsType name]
instance (OutputableBndr name)
=> Outputable (DefaultDecl name) where
- ppr (DefaultDecl tys src_loc)
+ ppr (DefaultDecl tys)
= ptext SLIT("default") <+> parens (interpp'SP tys)
\end{code}
-- foreign declarations are distinguished as to whether they define or use a
-- Haskell name
--
--- * the Boolean value indicates whether the pre-standard deprecated syntax
+-- * the Boolean value indicates whether the pre-standard deprecated syntax
-- has been used
--
+type LForeignDecl name = Located (ForeignDecl name)
+
data ForeignDecl name
- = ForeignImport name (HsType name) ForeignImport Bool SrcLoc -- defines name
- | ForeignExport name (HsType name) ForeignExport Bool SrcLoc -- uses name
+ = ForeignImport (Located name) (LHsType name) ForeignImport Bool -- defines name
+ | ForeignExport (Located name) (LHsType name) ForeignExport Bool -- uses name
-- specification of an imported external entity in dependence on the calling
-- convention
--
data ForeignImport = -- import of a C entity
--
- -- * the two strings specifying a header file or library
+ -- * the two strings specifying a header file or library
-- may be empty, which indicates the absence of a
-- header or object specification (both are not used
-- in the case of `CWrapper' and when `CFunction'
-- has a dynamic target)
--
- -- * the calling convention is irrelevant for code
+ -- * the calling convention is irrelevant for code
-- generation in the case of `CLabel', but is needed
-- for pretty printing
--
- -- * `Safety' is irrelevant for `CLabel' and `CWrapper'
+ -- * `Safety' is irrelevant for `CLabel' and `CWrapper'
--
CImport CCallConv -- ccall or stdcall
Safety -- safe or unsafe
--
instance OutputableBndr name => Outputable (ForeignDecl name) where
- ppr (ForeignImport n ty fimport _ _) =
+ ppr (ForeignImport n ty fimport _) =
ptext SLIT("foreign import") <+> ppr fimport <+>
ppr n <+> dcolon <+> ppr ty
- ppr (ForeignExport n ty fexport _ _) =
+ ppr (ForeignExport n ty fexport _) =
ptext SLIT("foreign export") <+> ppr fexport <+>
ppr n <+> dcolon <+> ppr ty
ptext SLIT("dynamic")
pprCEntity _ _ (CWrapper) = ptext SLIT("wrapper")
--
- pprLib lib | nullFastString lib = empty
- | otherwise = char '[' <> ppr lib <> char ']'
+ pprLib lib | nullFS lib = empty
+ | otherwise = char '[' <> ppr lib <> char ']'
instance Outputable ForeignExport where
ppr (CExport (CExportStatic lbl cconv)) =
%************************************************************************
\begin{code}
+type LRuleDecl name = Located (RuleDecl name)
+
data RuleDecl name
= HsRule -- Source rule
RuleName -- Rule name
Activation
[RuleBndr name] -- Forall'd vars; after typechecking this includes tyvars
- (HsExpr name) -- LHS
- (HsExpr name) -- RHS
- SrcLoc
+ (Located (HsExpr name)) -- LHS
+ NameSet -- Free-vars from the LHS
+ (Located (HsExpr name)) -- RHS
+ NameSet -- Free-vars from the RHS
data RuleBndr name
- = RuleBndr name
- | RuleBndrSig name (HsType name)
+ = RuleBndr (Located name)
+ | RuleBndrSig (Located name) (LHsType name)
-collectRuleBndrSigTys :: [RuleBndr name] -> [HsType name]
+collectRuleBndrSigTys :: [RuleBndr name] -> [LHsType name]
collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ ty <- bndrs]
instance OutputableBndr name => Outputable (RuleDecl name) where
- ppr (HsRule name act ns lhs rhs loc)
+ ppr (HsRule name act ns lhs fv_lhs rhs fv_rhs)
= sep [text "{-# RULES" <+> doubleQuotes (ftext name) <+> ppr act,
- nest 4 (pp_forall <+> pprExpr lhs),
- nest 4 (equals <+> pprExpr rhs <+> text "#-}") ]
+ nest 4 (pp_forall <+> pprExpr (unLoc lhs)),
+ nest 4 (equals <+> pprExpr (unLoc rhs) <+> text "#-}") ]
where
pp_forall | null ns = empty
| otherwise = text "forall" <+> fsep (map ppr ns) <> dot
We use exported entities for things to deprecate.
\begin{code}
-data DeprecDecl name = Deprecation name DeprecTxt SrcLoc
+type LDeprecDecl name = Located (DeprecDecl name)
+
+data DeprecDecl name = Deprecation name DeprecTxt
instance OutputableBndr name => Outputable (DeprecDecl name) where
- ppr (Deprecation thing txt _)
+ ppr (Deprecation thing txt)
= hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"]
\end{code}
projects / ghc-hetmet.git / blobdiff