DeprecDecl(..), LDeprecDecl,
HsGroup(..), emptyRdrGroup, emptyRnGroup, appendGroups,
tcdName, tyClDeclNames, tyClDeclTyVars,
- isClassDecl, isSynDecl, isDataDecl,
+ isClassDecl, isTFunDecl, isSynDecl, isDataDecl, isKindSigDecl,
+ isIdxTyDecl,
countTyClDecls,
conDetailsTys,
+ instDeclATs,
collectRuleBndrSigTys,
) where
import HsImpExp ( pprHsVar )
import HsTypes
import NameSet ( NameSet )
-import HscTypes ( DeprecTxt )
import CoreSyn ( RuleName )
-import Kind ( Kind, pprKind )
-import BasicTypes ( Activation(..) )
+import {- Kind parts of -} Type ( Kind, pprKind )
+import BasicTypes ( Activation(..), DeprecTxt )
import ForeignCall ( CCallTarget(..), DNCallSpec, CCallConv, Safety,
CExportSpec(..), CLabelString )
-- others:
-import FunDeps ( pprFundeps )
-import Class ( FunDep )
+import Class ( FunDep, pprFundeps )
import Outputable
import Util ( count )
import SrcLoc ( Located(..), unLoc, noLoc )
import FastString
+import Maybe ( isJust )
\end{code}
-- for a module. That's why (despite the misnomer) IfaceSig and ForeignType
-- are both in TyClDecl
+-- Representation of indexed types
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-- Kind signatures of indexed types come in two flavours:
+--
+-- * kind signatures for type functions: variant `TyFunction' and
+--
+-- * kind signatures for indexed data types and newtypes : variant `TyData'
+-- iff a kind is present in `tcdKindSig' and there are no constructors in
+-- `tcdCons'.
+--
+-- Indexed types are represented by 'TyData' and 'TySynonym' using the field
+-- 'tcdTyPats::Maybe [LHsType name]', with the following meaning:
+--
+-- * If it is 'Nothing', we have a *vanilla* data type declaration or type
+-- synonym declaration and 'tcdVars' contains the type parameters of the
+-- type constructor.
+--
+-- * If it is 'Just pats', we have the definition of an indexed type Then,
+-- 'pats' are type patterns for the type-indexes of the type constructor
+-- and 'tcdVars' are the variables in those patterns. Hence, the arity of
+-- the indexed type (ie, the number of indexes) is 'length tcdTyPats' and
+-- *not* 'length tcdVars'.
+--
+-- In both cases, 'tcdVars' collects all variables we need to quantify over.
+
type LTyClDecl name = Located (TyClDecl name)
data TyClDecl name
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)
+ tcdTyPats :: Maybe [LHsType name], -- Type patterns
+ tcdKindSig:: Maybe Kind, -- Optional kind sig;
+ -- (only for the
+ -- 'where' form and
+ -- indexed type sigs)
tcdCons :: [LConDecl name], -- Data constructors
-- For data T a = T1 | T2 a the LConDecls all have ResTyH98
-- are non-empty for the newtype-deriving case
}
+ | TyFunction {tcdLName :: Located name, -- type constructor
+ tcdTyVars :: [LHsTyVarBndr name], -- type variables
+ tcdIso :: Bool, -- injective type?
+ tcdKind :: Kind -- result kind
+ }
+
| TySynonym { tcdLName :: Located name, -- type constructor
tcdTyVars :: [LHsTyVarBndr name], -- type variables
+ tcdTyPats :: Maybe [LHsType name], -- Type patterns
+ -- 'Nothing' => vanilla
+ -- type synonym
tcdSynRhs :: LHsType name -- synonym expansion
}
tcdTyVars :: [LHsTyVarBndr name], -- Class type variables
tcdFDs :: [Located (FunDep name)], -- Functional deps
tcdSigs :: [LSig name], -- Methods' signatures
- tcdMeths :: LHsBinds name -- Default methods
+ tcdMeths :: LHsBinds name, -- Default methods
+ tcdATs :: [LTyClDecl name] -- Associated types; ie
+ -- only 'TyData',
+ -- 'TyFunction',
+ -- and 'TySynonym'
}
data NewOrData
Simple classifiers
\begin{code}
-isDataDecl, isSynDecl, isClassDecl :: TyClDecl name -> Bool
+isTFunDecl, isDataDecl, isSynDecl, isClassDecl, isKindSigDecl, isIdxTyDecl ::
+ TyClDecl name -> Bool
+
+-- type function kind signature
+isTFunDecl (TyFunction {}) = True
+isTFunDecl other = False
+
+-- vanilla Haskell type synonym
+isSynDecl (TySynonym {tcdTyPats = Nothing}) = True
+isSynDecl other = False
-isSynDecl (TySynonym {}) = True
-isSynDecl other = False
+-- type equation (of a type function)
+isTEqnDecl (TySynonym {tcdTyPats = Just _}) = True
+isTEqnDecl other = False
isDataDecl (TyData {}) = True
isDataDecl other = False
isClassDecl (ClassDecl {}) = True
isClassDecl other = False
+
+-- kind signature (for an indexed type)
+isKindSigDecl (TyFunction {} ) = True
+isKindSigDecl (TyData {tcdKindSig = Just _,
+ tcdCons = [] }) = True
+isKindSigDecl other = False
+
+-- definition of an instance of an indexed type
+isIdxTyDecl tydecl
+ | isTEqnDecl tydecl = True
+ | isDataDecl tydecl = isJust (tcdTyPats tydecl)
+ | otherwise = False
\end{code}
Dealing with names
-- For record fields, the first one counts as the SrcLoc
-- We use the equality to filter out duplicate field names
-tyClDeclNames (TySynonym {tcdLName = name}) = [name]
-tyClDeclNames (ForeignType {tcdLName = name}) = [name]
+tyClDeclNames (TyFunction {tcdLName = name}) = [name]
+tyClDeclNames (TySynonym {tcdLName = name}) = [name]
+tyClDeclNames (ForeignType {tcdLName = name}) = [name]
-tyClDeclNames (ClassDecl {tcdLName = cls_name, tcdSigs = sigs})
- = cls_name : [n | L _ (TypeSig n _) <- sigs]
+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 (TySynonym {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
-tyClDeclTyVars (ForeignType {}) = []
+tyClDeclTyVars (TyFunction {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (TySynonym {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (TyData {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (ClassDecl {tcdTyVars = tvs}) = tvs
+tyClDeclTyVars (ForeignType {}) = []
\end{code}
\begin{code}
-countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int)
- -- class, data, newtype, synonym decls
+countTyClDecls :: [TyClDecl name] -> (Int, Int, Int, Int, Int, Int)
+ -- class, synonym decls, type function signatures,
+ -- type function equations, data, newtype
countTyClDecls decls
= (count isClassDecl decls,
count isSynDecl decls,
+ count isTFunDecl decls,
+ count isTEqnDecl decls,
count isDataTy decls,
count isNewTy decls)
where
ppr (ForeignType {tcdLName = ltycon})
= hsep [ptext SLIT("foreign import type dotnet"), ppr ltycon]
- ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdSynRhs = mono_ty})
- = hang (ptext SLIT("type") <+> pp_decl_head [] ltycon tyvars <+> equals)
+ ppr (TyFunction {tcdLName = ltycon, tcdTyVars = tyvars, tcdIso = iso,
+ tcdKind = kind})
+ = typeMaybeIso <+> pp_decl_head [] ltycon tyvars Nothing <+>
+ dcolon <+> pprKind kind
+ where
+ typeMaybeIso = if iso
+ then ptext SLIT("type family iso")
+ else ptext SLIT("type family")
+
+ ppr (TySynonym {tcdLName = ltycon, tcdTyVars = tyvars, tcdTyPats = typats,
+ tcdSynRhs = mono_ty})
+ = hang (ptext SLIT("type") <+>
+ (if isJust typats then ptext SLIT("instance") else empty) <+>
+ pp_decl_head [] ltycon tyvars typats <+>
+ equals)
4 (ppr mono_ty)
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 (unLoc context) ltycon tyvars <+> ppr_sig mb_sig)
+ tcdTyVars = tyvars, tcdTyPats = typats, tcdKindSig = mb_sig,
+ tcdCons = condecls, tcdDerivs = derivings})
+ = pp_tydecl (null condecls && isJust mb_sig)
+ (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)
(pp_condecls condecls)
derivings
where
ppr_sig Nothing = empty
ppr_sig (Just kind) = dcolon <+> pprKind kind
- ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars, tcdFDs = fds,
- tcdSigs = sigs, tcdMeths = methods})
- | null sigs -- No "where" part
+ ppr (ClassDecl {tcdCtxt = context, tcdLName = lclas, tcdTyVars = tyvars,
+ tcdFDs = fds,
+ tcdSigs = sigs, tcdMeths = methods, tcdATs = ats})
+ | null sigs && null ats -- No "where" part
= top_matter
| otherwise -- Laid out
= sep [hsep [top_matter, ptext SLIT("where {")],
- nest 4 (sep [sep (map ppr_sig sigs), pprLHsBinds methods, char '}'])]
+ nest 4 (sep [ sep (map ppr_semi ats)
+ , sep (map ppr_semi sigs)
+ , pprLHsBinds methods
+ , char '}'])]
where
- top_matter = ptext SLIT("class") <+> pp_decl_head (unLoc context) lclas tyvars <+> pprFundeps (map unLoc fds)
- ppr_sig sig = ppr sig <> semi
+ top_matter = ptext SLIT("class")
+ <+> pp_decl_head (unLoc context) lclas tyvars Nothing
+ <+> pprFundeps (map unLoc fds)
+ ppr_semi decl = ppr decl <> semi
pp_decl_head :: OutputableBndr name
=> HsContext name
-> Located name
-> [LHsTyVarBndr name]
+ -> Maybe [LHsType name]
-> SDoc
-pp_decl_head context thing tyvars
+pp_decl_head context thing tyvars Nothing -- no explicit type patterns
= hsep [pprHsContext context, ppr thing, interppSP tyvars]
+pp_decl_head context thing _ (Just typats) -- explicit type patterns
+ = hsep [ pprHsContext context, ppr thing
+ , hsep (map (pprParendHsType.unLoc) typats)]
+
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
+pp_tydecl True pp_head pp_decl_rhs derivings
+ = 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)]
+ pp_decl_rhs,
+ case derivings of
+ Nothing -> empty
+ Just ds -> hsep [ptext SLIT("deriving"), parens (interpp'SP ds)]
])
instance Outputable NewOrData where
-- Using a polytype means that the renamer conveniently
-- figures out the quantified type variables for us.
(LHsBinds name)
- [LSig name] -- User-supplied pragmatic info
+ [LSig name] -- User-supplied pragmatic info
+ [LTyClDecl name]-- Associated types (ie, 'TyData' and
+ -- 'TySynonym' only)
instance (OutputableBndr name) => Outputable (InstDecl name) where
- ppr (InstDecl inst_ty binds uprags)
+ 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) ]
+
+-- Extract the declarations of associated types from an instance
+--
+instDeclATs :: InstDecl name -> [LTyClDecl name]
+instDeclATs (InstDecl _ _ _ ats) = ats
\end{code}
%************************************************************************
type LForeignDecl name = Located (ForeignDecl name)
data ForeignDecl name
- = ForeignImport (Located name) (LHsType name) ForeignImport Bool -- defines name
- | ForeignExport (Located name) (LHsType name) ForeignExport Bool -- uses name
+ = ForeignImport (Located name) (LHsType name) ForeignImport -- defines name
+ | ForeignExport (Located name) (LHsType name) ForeignExport -- uses name
--- specification of an imported external entity in dependence on the calling
+-- Specification Of an imported external entity in dependence on the calling
-- convention
--
data ForeignImport = -- import of a C entity
--
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
projects / ghc-hetmet.git / blobdiff