X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FhsSyn%2FHsDecls.lhs;h=3712cbd9f72c6777d5beafe3ff108d857dd37c57;hp=f559d4b3956d7636d7143e5e906f615524b52699;hb=c5b178be60a5a44abd2f4ddf8c399857678326e2;hpb=e63e94a280a727854ef1a3e03f14afedf9f94fc9 diff --git a/compiler/hsSyn/HsDecls.lhs b/compiler/hsSyn/HsDecls.lhs index f559d4b..3712cbd 100644 --- a/compiler/hsSyn/HsDecls.lhs +++ b/compiler/hsSyn/HsDecls.lhs @@ -3,15 +3,8 @@ % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % - - \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 +{-# LANGUAGE DeriveDataTypeable #-} -- | Abstract syntax of global declarations. -- @@ -23,7 +16,7 @@ module HsDecls ( -- ** Class or type declarations TyClDecl(..), LTyClDecl, isClassDecl, isSynDecl, isDataDecl, isTypeDecl, isFamilyDecl, - isFamInstDecl, tcdName, tyClDeclNames, tyClDeclTyVars, + isFamInstDecl, tcdName, tyClDeclTyVars, countTyClDecls, -- ** Instance declarations InstDecl(..), LInstDecl, NewOrData(..), FamilyFlavour(..), @@ -33,27 +26,33 @@ module HsDecls ( -- ** @RULE@ declarations RuleDecl(..), LRuleDecl, RuleBndr(..), collectRuleBndrSigTys, + -- ** @VECTORISE@ declarations + VectDecl(..), LVectDecl, + lvectDeclName, -- ** @default@ declarations DefaultDecl(..), LDefaultDecl, -- ** Top-level template haskell splice SpliceDecl(..), -- ** Foreign function interface declarations ForeignDecl(..), LForeignDecl, ForeignImport(..), ForeignExport(..), - CImportSpec(..), FoType(..), + CImportSpec(..), -- ** Data-constructor declarations - ConDecl(..), LConDecl, ResType(..), ConDeclField(..), - HsConDeclDetails, hsConDeclArgTys, + ConDecl(..), LConDecl, ResType(..), + HsConDeclDetails, hsConDeclArgTys, -- ** Document comments DocDecl(..), LDocDecl, docDeclDoc, -- ** Deprecations WarnDecl(..), LWarnDecl, + -- ** Annotations + AnnDecl(..), LAnnDecl, + AnnProvenance(..), annProvenanceName_maybe, modifyAnnProvenanceNameM, -- * Grouping - HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups, -) where + HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups + ) where -- friends: -import {-# SOURCE #-} HsExpr( HsExpr, pprExpr ) +import {-# SOURCE #-} HsExpr( LHsExpr, HsExpr, pprExpr ) -- Because Expr imports Decls via HsBracket import HsBinds @@ -72,6 +71,8 @@ import Util import SrcLoc import FastString +import Control.Monad ( liftM ) +import Data.Data import Data.Maybe ( isJust ) \end{code} @@ -94,9 +95,13 @@ data HsDecl id | DefD (DefaultDecl id) | ForD (ForeignDecl id) | WarningD (WarnDecl id) + | AnnD (AnnDecl id) | RuleD (RuleDecl id) + | VectD (VectDecl id) | SpliceD (SpliceDecl id) - | DocD (DocDecl id) + | DocD (DocDecl) + | QuasiQuoteD (HsQuasiQuote id) + deriving (Data, Typeable) -- NB: all top-level fixity decls are contained EITHER @@ -117,7 +122,12 @@ data HsDecl id data HsGroup id = HsGroup { hs_valds :: HsValBinds id, - hs_tyclds :: [LTyClDecl id], + + hs_tyclds :: [[LTyClDecl id]], + -- A list of mutually-recursive groups + -- Parser generates a singleton list; + -- renamer does dependency analysis + hs_instds :: [LInstDecl id], hs_derivds :: [LDerivDecl id], @@ -125,60 +135,68 @@ data HsGroup id -- Snaffled out of both top-level fixity signatures, -- and those in class declarations - hs_defds :: [LDefaultDecl id], - hs_fords :: [LForeignDecl id], - hs_warnds :: [LWarnDecl id], - hs_ruleds :: [LRuleDecl id], + hs_defds :: [LDefaultDecl id], + hs_fords :: [LForeignDecl id], + hs_warnds :: [LWarnDecl id], + hs_annds :: [LAnnDecl id], + hs_ruleds :: [LRuleDecl id], + hs_vects :: [LVectDecl id], - hs_docs :: [LDocDecl id] - } + hs_docs :: [LDocDecl] + } deriving (Data, Typeable) emptyGroup, emptyRdrGroup, emptyRnGroup :: HsGroup a emptyRdrGroup = emptyGroup { hs_valds = emptyValBindsIn } emptyRnGroup = emptyGroup { hs_valds = emptyValBindsOut } emptyGroup = HsGroup { hs_tyclds = [], hs_instds = [], hs_derivds = [], - hs_fixds = [], hs_defds = [], hs_fords = [], - hs_warnds = [], hs_ruleds = [], + hs_fixds = [], hs_defds = [], hs_annds = [], + hs_fords = [], hs_warnds = [], hs_ruleds = [], hs_vects = [], hs_valds = error "emptyGroup hs_valds: Can't happen", hs_docs = [] } appendGroups :: HsGroup a -> HsGroup a -> HsGroup a appendGroups HsGroup { - hs_valds = val_groups1, - hs_tyclds = tyclds1, - hs_instds = instds1, + hs_valds = val_groups1, + hs_tyclds = tyclds1, + hs_instds = instds1, hs_derivds = derivds1, - hs_fixds = fixds1, - hs_defds = defds1, - hs_fords = fords1, - hs_warnds = warnds1, - hs_ruleds = rulds1, + hs_fixds = fixds1, + hs_defds = defds1, + hs_annds = annds1, + hs_fords = fords1, + hs_warnds = warnds1, + hs_ruleds = rulds1, + hs_vects = vects1, hs_docs = docs1 } HsGroup { - hs_valds = val_groups2, - hs_tyclds = tyclds2, - hs_instds = instds2, + hs_valds = val_groups2, + hs_tyclds = tyclds2, + hs_instds = instds2, hs_derivds = derivds2, - hs_fixds = fixds2, - hs_defds = defds2, - hs_fords = fords2, - hs_warnds = warnds2, - hs_ruleds = rulds2, - hs_docs = docs2 } + hs_fixds = fixds2, + hs_defds = defds2, + hs_annds = annds2, + hs_fords = fords2, + hs_warnds = warnds2, + hs_ruleds = rulds2, + hs_vects = vects2, + hs_docs = docs2 } = HsGroup { - hs_valds = val_groups1 `plusHsValBinds` val_groups2, - hs_tyclds = tyclds1 ++ tyclds2, - hs_instds = instds1 ++ instds2, + hs_valds = val_groups1 `plusHsValBinds` val_groups2, + hs_tyclds = tyclds1 ++ tyclds2, + hs_instds = instds1 ++ instds2, hs_derivds = derivds1 ++ derivds2, - hs_fixds = fixds1 ++ fixds2, - hs_defds = defds1 ++ defds2, - hs_fords = fords1 ++ fords2, - hs_warnds = warnds1 ++ warnds2, - hs_ruleds = rulds1 ++ rulds2, - hs_docs = docs1 ++ docs2 } + hs_fixds = fixds1 ++ fixds2, + hs_annds = annds1 ++ annds2, + hs_defds = defds1 ++ defds2, + hs_fords = fords1 ++ fords2, + hs_warnds = warnds1 ++ warnds2, + hs_ruleds = rulds1 ++ rulds2, + hs_vects = vects1 ++ vects2, + hs_docs = docs1 ++ docs2 } \end{code} \begin{code} @@ -191,9 +209,12 @@ instance OutputableBndr name => Outputable (HsDecl name) where ppr (ForD fd) = ppr fd ppr (SigD sd) = ppr sd ppr (RuleD rd) = ppr rd + ppr (VectD vect) = ppr vect ppr (WarningD wd) = ppr wd + ppr (AnnD ad) = ppr ad ppr (SpliceD dd) = ppr dd ppr (DocD doc) = ppr doc + ppr (QuasiQuoteD qq) = ppr qq instance OutputableBndr name => Outputable (HsGroup name) where ppr (HsGroup { hs_valds = val_decls, @@ -202,23 +223,43 @@ instance OutputableBndr name => Outputable (HsGroup name) where hs_derivds = deriv_decls, hs_fixds = fix_decls, hs_warnds = deprec_decls, + hs_annds = ann_decls, hs_fords = foreign_decls, hs_defds = default_decls, - hs_ruleds = rule_decls }) - = vcat [ppr_ds fix_decls, ppr_ds default_decls, - ppr_ds deprec_decls, ppr_ds rule_decls, - ppr val_decls, - ppr_ds tycl_decls, ppr_ds inst_decls, - ppr_ds deriv_decls, - ppr_ds foreign_decls] + hs_ruleds = rule_decls, + hs_vects = vect_decls }) + = vcat_mb empty + [ppr_ds fix_decls, ppr_ds default_decls, + ppr_ds deprec_decls, ppr_ds ann_decls, + ppr_ds rule_decls, + ppr_ds vect_decls, + if isEmptyValBinds val_decls + then Nothing + else Just (ppr val_decls), + ppr_ds (concat tycl_decls), + ppr_ds inst_decls, + ppr_ds deriv_decls, + ppr_ds foreign_decls] where - ppr_ds [] = empty - ppr_ds ds = text "" $$ vcat (map ppr ds) - -data SpliceDecl id = SpliceDecl (Located (HsExpr id)) -- Top level splice + ppr_ds :: Outputable a => [a] -> Maybe SDoc + ppr_ds [] = Nothing + ppr_ds ds = Just (vcat (map ppr ds)) + + vcat_mb :: SDoc -> [Maybe SDoc] -> SDoc + -- Concatenate vertically with white-space between non-blanks + vcat_mb _ [] = empty + vcat_mb gap (Nothing : ds) = vcat_mb gap ds + vcat_mb gap (Just d : ds) = gap $$ d $$ vcat_mb blankLine ds + +data SpliceDecl id + = SpliceDecl -- Top level splice + (Located (HsExpr id)) + HsExplicitFlag -- Explicit <=> $(f x y) + -- Implicit <=> f x y, i.e. a naked top level expression + deriving (Data, Typeable) 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} @@ -389,13 +430,12 @@ type LTyClDecl name = Located (TyClDecl name) data TyClDecl name = ForeignType { tcdLName :: Located name, - tcdExtName :: Maybe FastString, - tcdFoType :: FoType + tcdExtName :: Maybe FastString } - | -- | @type/data/newtype family T :: *->*@ - TyFamily { tcdFlavour:: FamilyFlavour, -- type, new, or data + | -- | @type/data family T :: *->*@ + TyFamily { tcdFlavour:: FamilyFlavour, -- type or data tcdLName :: Located name, -- type constructor tcdTyVars :: [LHsTyVarBndr name], -- type variables tcdKind :: Maybe Kind -- result kind @@ -465,17 +505,19 @@ data TyClDecl name -- only 'TyFamily' and -- 'TySynonym'; the -- latter for defaults - tcdDocs :: [LDocDecl name] -- ^ Haddock docs + tcdDocs :: [LDocDecl] -- ^ Haddock docs } + deriving (Data, Typeable) data NewOrData = NewType -- ^ @newtype Blah ...@ | DataType -- ^ @data Blah ...@ - deriving( Eq ) -- Needed because Demand derives Eq + deriving( Eq, Data, Typeable ) -- Needed because Demand derives Eq data FamilyFlavour = TypeFamily -- ^ @type family ...@ | DataFamily -- ^ @data family ...@ + deriving (Data, Typeable) \end{code} Simple classifiers @@ -521,23 +563,6 @@ Dealing with names tcdName :: TyClDecl name -> name tcdName decl = unLoc (tcdLName decl) -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 (TyFamily {tcdLName = name}) = [name] -tyClDeclNames (TySynonym {tcdLName = name}) = [name] -tyClDeclNames (ForeignType {tcdLName = name}) = [name] - -tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs, tcdATs = ats}) - = cls_name : - concatMap (tyClDeclNames . unLoc) ats ++ [n | L _ (TypeSig n _) <- sigs] - -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 @@ -598,15 +623,15 @@ instance OutputableBndr name (ppr new_or_data <+> (if isJust typats then ptext (sLit "instance") else empty) <+> pp_decl_head (unLoc context) ltycon tyvars typats <+> - ppr_sig mb_sig) + ppr_sigx mb_sig) (pp_condecls condecls) derivings where - ppr_sig Nothing = empty - ppr_sig (Just kind) = dcolon <+> pprKind kind + ppr_sigx Nothing = empty + ppr_sigx (Just kind) = dcolon <+> pprKind kind ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars, - tcdFDs = fds, + tcdFDs = fds, tcdSigs = sigs, tcdMeths = methods, tcdATs = ats}) | null sigs && null ats -- No "where" part = top_matter @@ -621,6 +646,7 @@ instance OutputableBndr name top_matter = ptext (sLit "class") <+> pp_decl_head (unLoc context) lclas tyvars Nothing <+> pprFundeps (map unLoc fds) + ppr_semi :: Outputable a => a -> SDoc ppr_semi decl = ppr decl <> semi pp_decl_head :: OutputableBndr name @@ -681,23 +707,39 @@ type LConDecl name = Located (ConDecl name) data ConDecl name = ConDecl - { con_name :: Located name -- Constructor name; this is used for the - -- DataCon itself, and for the user-callable wrapper Id + { 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_explicit :: HsExplicitFlag + -- ^ 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_qvars :: [LHsTyVarBndr name] + -- ^ Type variables. Depending on 'con_res' this describes the + -- follewing entities + -- + -- - 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 + , con_cxt :: LHsContext name + -- ^ The context. This /does not/ include the \"stupid theta\" which + -- lives only in the 'TyData' decl. - , con_details :: HsConDeclDetails name -- The main payload + , con_details :: HsConDeclDetails name + -- ^ The main payload - , con_res :: ResType name -- Result type of the constructor + , con_res :: ResType name + -- ^ Result type of the constructor - , con_doc :: Maybe (LHsDoc name) -- A possible Haddock comment - } + , con_doc :: Maybe LHsDocString + -- ^ A possible Haddock comment. + + , con_old_rec :: Bool + -- ^ TEMPORARY field; True <=> user has employed now-deprecated syntax for + -- GADT-style record decl C { blah } :: T a b + -- Remove this when we no longer parse this stuff, and hence do not + -- need to report decprecated use + } deriving (Data, Typeable) type HsConDeclDetails name = HsConDetails (LBangType name) [ConDeclField name] @@ -706,73 +748,54 @@ 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, -- and here is its result type -\end{code} - -\begin{code} -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 { con_name = lname, con_details = RecCon flds }) - = (map unLoc new_flds ++ flds_seen, lname : new_flds ++ acc) - where - new_flds = filterOut (\f -> unLoc f `elem` flds_seen) - (map cd_fld_name flds) + deriving (Data, Typeable) - do_one (flds_seen, acc) c - = (flds_seen, (con_name c):acc) +instance OutputableBndr name => Outputable (ResType name) where + -- Debugging only + ppr ResTyH98 = ptext (sLit "ResTyH98") + ppr (ResTyGADT ty) = ptext (sLit "ResTyGADT") <+> pprParendHsType (unLoc ty) \end{code} - + \begin{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] +pprConDecl (ConDecl { con_name = con, con_explicit = expl, con_qvars = tvs + , con_cxt = cxt, con_details = details + , con_res = ResTyH98, con_doc = doc }) + = sep [ppr_mbDoc doc, pprHsForAll expl tvs cxt, ppr_details details] where - 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 + ppr_details (InfixCon t1 t2) = hsep [ppr t1, pprHsInfix con, ppr t2] + ppr_details (PrefixCon tys) = hsep (pprHsVar con : map ppr tys) + ppr_details (RecCon fields) = ppr con <+> pprConDeclFields fields -pprConDecl (ConDecl con expl tvs cxt (PrefixCon arg_tys) (ResTyGADT res_ty) _) +pprConDecl (ConDecl { con_name = con, con_explicit = expl, con_qvars = tvs + , con_cxt = cxt, con_details = PrefixCon arg_tys + , con_res = ResTyGADT res_ty }) = ppr con <+> dcolon <+> sep [pprHsForAll expl tvs cxt, ppr (foldr mk_fun_ty res_ty arg_tys)] where mk_fun_ty a b = noLoc (HsFunTy a b) -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_name = con, con_explicit = expl, con_qvars = tvs + , con_cxt = cxt, con_details = RecCon fields, con_res = ResTyGADT res_ty }) + = sep [ppr con <+> dcolon <+> pprHsForAll expl tvs cxt, + pprConDeclFields fields <+> arrow <+> ppr res_ty] -pprConDecl (ConDecl con _expl _tvs _cxt (InfixCon _ _) (ResTyGADT _res_ty) _) +pprConDecl (ConDecl {con_name = con, con_details = InfixCon {}, con_res = ResTyGADT {} }) = 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} %************************************************************************ %* * -\subsection[InstDecl]{An instance declaration +\subsection[InstDecl]{An instance declaration} %* * %************************************************************************ @@ -787,6 +810,7 @@ data InstDecl name [LSig name] -- User-supplied pragmatic info [LTyClDecl name]-- Associated types (ie, 'TyData' and -- 'TySynonym' only) + deriving (Data, Typeable) instance (OutputableBndr name) => Outputable (InstDecl name) where @@ -798,24 +822,25 @@ instance (OutputableBndr name) => Outputable (InstDecl name) where -- Extract the declarations of associated types from an instance -- -instDeclATs :: InstDecl name -> [LTyClDecl name] -instDeclATs (InstDecl _ _ _ ats) = ats +instDeclATs :: [LInstDecl name] -> [LTyClDecl name] +instDeclATs inst_decls = [at | L _ (InstDecl _ _ _ ats) <- inst_decls, at <- ats] \end{code} %************************************************************************ %* * -\subsection[DerivDecl]{A stand-alone instance deriving declaration +\subsection[DerivDecl]{A stand-alone instance deriving declaration} %* * %************************************************************************ \begin{code} type LDerivDecl name = Located (DerivDecl name) -data DerivDecl name = DerivDecl (LHsType name) +data DerivDecl name = DerivDecl { deriv_type :: LHsType name } + deriving (Data, Typeable) instance (OutputableBndr name) => Outputable (DerivDecl name) where ppr (DerivDecl ty) - = hsep [ptext (sLit "derived instance"), ppr ty] + = hsep [ptext (sLit "deriving instance"), ppr ty] \end{code} %************************************************************************ @@ -833,6 +858,7 @@ type LDefaultDecl name = Located (DefaultDecl name) data DefaultDecl name = DefaultDecl [LHsType name] + deriving (Data, Typeable) instance (OutputableBndr name) => Outputable (DefaultDecl name) where @@ -860,6 +886,7 @@ type LForeignDecl name = Located (ForeignDecl name) data ForeignDecl name = ForeignImport (Located name) (LHsType name) ForeignImport -- defines name | ForeignExport (Located name) (LHsType name) ForeignExport -- uses name + deriving (Data, Typeable) -- Specification Of an imported external entity in dependence on the calling -- convention @@ -879,14 +906,10 @@ data ForeignImport = -- import of a C entity -- * `Safety' is irrelevant for `CLabel' and `CWrapper' -- CImport CCallConv -- ccall or stdcall - Safety -- safe or unsafe + Safety -- interruptible, safe or unsafe FastString -- name of C header - FastString -- name of library object CImportSpec -- details of the C entity - - -- import of a .NET function - -- - | DNImport DNCallSpec + deriving (Data, Typeable) -- details of an external C entity -- @@ -894,18 +917,13 @@ data CImportSpec = CLabel CLabelString -- import address of a C label | CFunction CCallTarget -- static or dynamic function | CWrapper -- wrapper to expose closures -- (former f.e.d.) + deriving (Data, Typeable) -- specification of an externally exported entity in dependence on the calling -- convention -- data ForeignExport = CExport CExportSpec -- contains the calling convention - | DNExport -- presently unused - --- abstract type imported from .NET --- -data FoType = DNType -- In due course we'll add subtype stuff - deriving (Eq) -- Used for equality instance for TyClDecl - + deriving (Data, Typeable) -- pretty printing of foreign declarations -- @@ -919,33 +937,23 @@ instance OutputableBndr name => Outputable (ForeignDecl name) where 2 (dcolon <+> ppr ty) instance Outputable ForeignImport where - ppr (DNImport spec) = - ptext (sLit "dotnet") <+> ppr spec - ppr (CImport cconv safety header lib spec) = + ppr (CImport cconv safety header spec) = ppr cconv <+> ppr safety <+> - char '"' <> pprCEntity header lib spec <> char '"' + char '"' <> pprCEntity spec <> char '"' where - pprCEntity header lib (CLabel lbl) = - ptext (sLit "static") <+> ftext header <+> char '&' <> - pprLib lib <> ppr lbl - pprCEntity header lib (CFunction (StaticTarget lbl)) = - ptext (sLit "static") <+> ftext header <+> char '&' <> - pprLib lib <> ppr lbl - pprCEntity _ _ (CFunction (DynamicTarget)) = + pp_hdr = if nullFS header then empty else ftext header + + pprCEntity (CLabel lbl) = + ptext (sLit "static") <+> pp_hdr <+> char '&' <> ppr lbl + pprCEntity (CFunction (StaticTarget lbl _)) = + ptext (sLit "static") <+> pp_hdr <+> ppr lbl + pprCEntity (CFunction (DynamicTarget)) = ptext (sLit "dynamic") - pprCEntity _ _ (CWrapper) = ptext (sLit "wrapper") - -- - pprLib lib | nullFS lib = empty - | otherwise = char '[' <> ppr lib <> char ']' + pprCEntity (CWrapper) = ptext (sLit "wrapper") instance Outputable ForeignExport where ppr (CExport (CExportStatic lbl cconv)) = ppr cconv <+> char '"' <> ppr lbl <> char '"' - ppr (DNExport ) = - ptext (sLit "dotnet") <+> ptext (sLit "\"\"") - -instance Outputable FoType where - ppr DNType = ptext (sLit "type dotnet") \end{code} @@ -967,10 +975,12 @@ data RuleDecl name NameSet -- Free-vars from the LHS (Located (HsExpr name)) -- RHS NameSet -- Free-vars from the RHS + deriving (Data, Typeable) data RuleBndr name = RuleBndr (Located name) | RuleBndrSig (Located name) (LHsType name) + deriving (Data, Typeable) collectRuleBndrSigTys :: [RuleBndr name] -> [LHsType name] collectRuleBndrSigTys bndrs = [ty | RuleBndrSig _ ty <- bndrs] @@ -989,6 +999,57 @@ instance OutputableBndr name => Outputable (RuleBndr name) where ppr (RuleBndrSig name ty) = ppr name <> dcolon <> ppr ty \end{code} + +%************************************************************************ +%* * +\subsection{Vectorisation declarations} +%* * +%************************************************************************ + +A vectorisation pragma, one of + + {-# VECTORISE f = closure1 g (scalar_map g) #-} + {-# VECTORISE SCALAR f #-} + {-# NOVECTORISE f #-} + +Note [Typechecked vectorisation pragmas] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +In case of the first variant of vectorisation pragmas (with an explicit expression), +we need to infer the type of that expression during type checking and then keep that type +around until vectorisation, so that it can be checked against the *vectorised* type of 'f'. +(We cannot determine vectorised types during type checking due to internal information of +the vectoriser being needed.) + +To this end, we annotate the 'Id' of 'f' (the variable mentioned in the PRAGMA) with the +inferred type of the expression. This is slightly dodgy, as this is really the type of +'$v_f' (the name of the vectorised function). + +\begin{code} +type LVectDecl name = Located (VectDecl name) + +data VectDecl name + = HsVect + (Located name) + (Maybe (LHsExpr name)) -- 'Nothing' => SCALAR declaration + | HsNoVect + (Located name) + deriving (Data, Typeable) + +lvectDeclName :: LVectDecl name -> name +lvectDeclName (L _ (HsVect (L _ name) _)) = name +lvectDeclName (L _ (HsNoVect (L _ name))) = name + +instance OutputableBndr name => Outputable (VectDecl name) where + ppr (HsVect v Nothing) + = sep [text "{-# VECTORISE SCALAR" <+> ppr v <+> text "#-}" ] + ppr (HsVect v (Just rhs)) + = sep [text "{-# VECTORISE" <+> ppr v, + nest 4 $ + pprExpr (unLoc rhs) <+> text "#-}" ] + ppr (HsNoVect v) + = sep [text "{-# NOVECTORISE" <+> ppr v <+> text "#-}" ] +\end{code} + %************************************************************************ %* * \subsection[DocDecl]{Document comments} @@ -997,19 +1058,20 @@ instance OutputableBndr name => Outputable (RuleBndr name) where \begin{code} -type LDocDecl name = Located (DocDecl name) +type LDocDecl = Located (DocDecl) -data DocDecl name - = DocCommentNext (HsDoc name) - | DocCommentPrev (HsDoc name) - | DocCommentNamed String (HsDoc name) - | DocGroup Int (HsDoc name) +data DocDecl + = DocCommentNext HsDocString + | DocCommentPrev HsDocString + | DocCommentNamed String HsDocString + | DocGroup Int HsDocString + deriving (Data, Typeable) -- Okay, I need to reconstruct the document comments, but for now: -instance Outputable (DocDecl name) where +instance Outputable DocDecl where ppr _ = text "" -docDeclDoc :: DocDecl name -> HsDoc name +docDeclDoc :: DocDecl -> HsDocString docDeclDoc (DocCommentNext d) = d docDeclDoc (DocCommentPrev d) = d docDeclDoc (DocCommentNamed _ d) = d @@ -1029,8 +1091,50 @@ We use exported entities for things to deprecate. type LWarnDecl name = Located (WarnDecl name) data WarnDecl name = Warning name WarningTxt + deriving (Data, Typeable) instance OutputableBndr name => Outputable (WarnDecl name) where ppr (Warning thing txt) = hsep [text "{-# DEPRECATED", ppr thing, doubleQuotes (ppr txt), text "#-}"] \end{code} + +%************************************************************************ +%* * +\subsection[AnnDecl]{Annotations} +%* * +%************************************************************************ + +\begin{code} +type LAnnDecl name = Located (AnnDecl name) + +data AnnDecl name = HsAnnotation (AnnProvenance name) (Located (HsExpr name)) + deriving (Data, Typeable) + +instance (OutputableBndr name) => Outputable (AnnDecl name) where + ppr (HsAnnotation provenance expr) + = hsep [text "{-#", pprAnnProvenance provenance, pprExpr (unLoc expr), text "#-}"] + + +data AnnProvenance name = ValueAnnProvenance name + | TypeAnnProvenance name + | ModuleAnnProvenance + deriving (Data, Typeable) + +annProvenanceName_maybe :: AnnProvenance name -> Maybe name +annProvenanceName_maybe (ValueAnnProvenance name) = Just name +annProvenanceName_maybe (TypeAnnProvenance name) = Just name +annProvenanceName_maybe ModuleAnnProvenance = Nothing + +-- TODO: Replace with Traversable instance when GHC bootstrap version rises high enough +modifyAnnProvenanceNameM :: Monad m => (before -> m after) -> AnnProvenance before -> m (AnnProvenance after) +modifyAnnProvenanceNameM fm prov = + case prov of + ValueAnnProvenance name -> liftM ValueAnnProvenance (fm name) + TypeAnnProvenance name -> liftM TypeAnnProvenance (fm name) + ModuleAnnProvenance -> return ModuleAnnProvenance + +pprAnnProvenance :: OutputableBndr name => AnnProvenance name -> SDoc +pprAnnProvenance ModuleAnnProvenance = ptext (sLit "ANN module") +pprAnnProvenance (ValueAnnProvenance name) = ptext (sLit "ANN") <+> ppr name +pprAnnProvenance (TypeAnnProvenance name) = ptext (sLit "ANN type") <+> ppr name +\end{code}