module PprType(
pprKind, pprParendKind,
pprType, pprParendType,
- pprConstraint, pprPred, pprTheta,
+ pprPred, pprTheta, pprThetaArrow, pprClassPred,
pprTyVarBndr, pprTyVarBndrs,
-- Junk
-- friends:
-- (PprType can see all the representations it's trying to print)
-import TypeRep ( Type(..), TyNote(..), Kind, UsageAnn(..),
- boxedTypeKind,
- ) -- friend
-import Type ( PredType(..), ThetaType,
- splitPredTy_maybe,
- splitForAllTys, splitSigmaTy, splitRhoTy,
- isDictTy, splitTyConApp_maybe, splitFunTy_maybe,
- splitUsForAllTys
- )
-import Var ( TyVar, tyVarKind,
- tyVarName, setTyVarName
- )
-import VarEnv
-import TyCon ( TyCon, isPrimTyCon, isTupleTyCon, isUnboxedTupleTyCon,
- maybeTyConSingleCon, isEnumerationTyCon,
- tyConArity, tyConUnique
- )
-import Class ( Class, className )
+import TypeRep ( Type(..), TyNote(..), PredType(..), TyThing(..), Kind, superKind ) -- friend
+import Type ( typeKind, eqKind )
+import IfaceType ( toIfaceType, toIfacePred, pprParendIfaceType,
+ toIfaceKind, pprParendIfaceKind,
+ getIfaceExt )
+
+import TcType ( ThetaType, PredType,
+ tcSplitSigmaTy, isDictTy,
+ tcSplitTyConApp_maybe, tcSplitFunTy_maybe
+ )
+import Var ( TyVar, tyVarKind )
+import Class ( Class )
+import TyCon ( isPrimTyCon, isTupleTyCon, maybeTyConSingleCon, isEnumerationTyCon )
-- others:
import Maybes ( maybeToBool )
-import Name ( getOccString, NamedThing(..) )
+import Name ( NamedThing(..), getOccString )
import Outputable
-import PprEnv
-import Unique ( Uniquable(..) )
-import Unique -- quite a few *Keys
-import Util
+import BasicTypes ( IPName(..), ipNameName )
+import PrelNames -- quite a few *Keys
\end{code}
%************************************************************************
\begin{code}
pprType, pprParendType :: Type -> SDoc
-pprType ty = ppr_ty pprTyEnv tOP_PREC ty
-pprParendType ty = ppr_ty pprTyEnv tYCON_PREC ty
+-- To save duplicating type-printing machinery,
+-- we print a type by converting to an IfaceType and printing that
+pprType ty = getIfaceExt $ \ ext ->
+ ppr (toIfaceType ext ty)
+pprParendType ty = getIfaceExt $ \ ext ->
+ pprParendIfaceType (toIfaceType ext ty)
pprKind, pprParendKind :: Kind -> SDoc
-pprKind = pprType
-pprParendKind = pprParendType
+pprKind k = ppr (toIfaceKind k)
+pprParendKind k = pprParendIfaceKind (toIfaceKind k)
pprPred :: PredType -> SDoc
-pprPred (Class clas tys) = pprConstraint clas tys
-pprPred (IParam n ty) = hsep [ppr n, ptext SLIT("::"), ppr ty]
+pprPred pred = getIfaceExt $ \ ext ->
+ ppr (toIfacePred ext pred)
-pprConstraint :: Class -> [Type] -> SDoc
-pprConstraint clas tys = ppr clas <+> hsep (map (pprParendType) tys)
+pprClassPred :: Class -> [Type] -> SDoc
+pprClassPred clas tys = ppr clas <+> sep (map pprParendType tys)
pprTheta :: ThetaType -> SDoc
-pprTheta theta = parens (hsep (punctuate comma (map pprPred theta)))
-
-instance Outputable Type where
- ppr ty = pprType ty
-\end{code}
-
-
-%************************************************************************
-%* *
-\subsection{Pretty printing}
-%* *
-%************************************************************************
-
-Precedence
-~~~~~~~~~~
-@ppr_ty@ takes an @Int@ that is the precedence of the context.
-The precedence levels are:
-\begin{description}
-\item[tOP_PREC] No parens required.
-\item[fUN_PREC] Left hand argument of a function arrow.
-\item[tYCON_PREC] Argument of a type constructor.
-\end{description}
+pprTheta theta = parens (sep (punctuate comma (map pprPred theta)))
+pprThetaArrow :: ThetaType -> SDoc
+pprThetaArrow theta
+ | null theta = empty
+ | otherwise = parens (sep (punctuate comma (map pprPred theta))) <+> ptext SLIT("=>")
-\begin{code}
-tOP_PREC = (0 :: Int)
-fUN_PREC = (1 :: Int)
-tYCON_PREC = (2 :: Int)
-
-maybeParen ctxt_prec inner_prec pretty
- | ctxt_prec < inner_prec = pretty
- | otherwise = parens pretty
-\end{code}
-
-\begin{code}
-ppr_ty :: PprEnv TyVar -> Int -> Type -> SDoc
-ppr_ty env ctxt_prec (TyVarTy tyvar)
- = pTyVarO env tyvar
-
-ppr_ty env ctxt_prec ty@(TyConApp tycon tys)
- -- KIND CASE; it's of the form (Type x)
- | tycon_uniq == typeConKey && n_tys == 1
- = -- For kinds, print (Type x) as just x if x is a
- -- type constructor (must be Boxed, Unboxed, AnyBox)
- -- Otherwise print as (Type x)
- case ty1 of
- TyConApp bx [] -> ppr bx
- other -> maybeParen ctxt_prec tYCON_PREC
- (sep [ppr tycon, nest 4 tys_w_spaces])
-
-
- -- TUPLE CASE (boxed and unboxed)
- | isTupleTyCon tycon
- && length tys == tyConArity tycon -- no magic if partially applied
- = parens tys_w_commas
-
- | isUnboxedTupleTyCon tycon
- && length tys == tyConArity tycon -- no magic if partially applied
- = parens (char '#' <+> tys_w_commas <+> char '#')
-
- -- LIST CASE
- | tycon_uniq == listTyConKey && n_tys == 1
- = brackets (ppr_ty env tOP_PREC ty1)
-
- -- DICTIONARY CASE, prints {C a}
- -- This means that instance decls come out looking right in interfaces
- -- and that in turn means they get "gated" correctly when being slurped in
- | maybeToBool maybe_pred
- = braces (ppr_pred env pred)
-
- -- NO-ARGUMENT CASE (=> no parens)
- | null tys
- = ppr tycon
-
- -- GENERAL CASE
- | otherwise
- = maybeParen ctxt_prec tYCON_PREC (sep [ppr tycon, nest 4 tys_w_spaces])
-
- where
- tycon_uniq = tyConUnique tycon
- n_tys = length tys
- (ty1:_) = tys
- Just pred = maybe_pred
- maybe_pred = splitPredTy_maybe ty -- Checks class and arity
- tys_w_commas = sep (punctuate comma (map (ppr_ty env tOP_PREC) tys))
- tys_w_spaces = sep (map (ppr_ty env tYCON_PREC) tys)
-
-
-
-ppr_ty env ctxt_prec ty@(ForAllTy _ _)
- = getPprStyle $ \ sty ->
- maybeParen ctxt_prec fUN_PREC $
- if ifaceStyle sty then
- sep [ ptext SLIT("__forall") <+> brackets pp_tyvars <+> ptext SLIT("=>"),
- ppr_ty env tOP_PREC rho
- ]
- else
- -- The type checker occasionally prints a type in an error message,
- -- and it had better come out looking like a user type
- sep [ ptext SLIT("forall") <+> pp_tyvars <> ptext SLIT("."),
- ppr_theta theta,
- ppr_ty env tOP_PREC tau
- ]
- where
- (tyvars, rho) = splitForAllTys ty -- don't treat theta specially any more (KSW 1999-04)
- (theta, tau) = splitRhoTy rho
-
- pp_tyvars = hsep (map (pBndr env LambdaBind) tyvars)
-
- ppr_theta [] = empty
- ppr_theta theta = parens (hsep (punctuate comma (map ppr_pred theta)))
- <+> ptext SLIT("=>")
-
- ppr_pred (Class clas tys) = ppr clas <+> hsep (map (ppr_ty env tYCON_PREC) tys)
- ppr_pred (IParam n ty) = hsep [{- char '?' <> -} ppr n, text "::",
- ppr_ty env tYCON_PREC ty]
-
-ppr_ty env ctxt_prec (FunTy ty1 ty2)
- = maybeParen ctxt_prec fUN_PREC (sep (ppr_ty env fUN_PREC ty1 : pp_rest ty2))
- -- we don't want to lose usage annotations or synonyms,
- -- so we mustn't use splitFunTys here.
- where
- pp_rest (FunTy ty1 ty2) = pp_codom ty1 : pp_rest ty2
- pp_rest ty = [pp_codom ty]
- pp_codom ty = ptext SLIT("->") <+> ppr_ty env fUN_PREC ty
-
-ppr_ty env ctxt_prec (AppTy ty1 ty2)
- = maybeParen ctxt_prec tYCON_PREC $
- ppr_ty env tOP_PREC ty1 <+> ppr_ty env tYCON_PREC ty2
-
-ppr_ty env ctxt_prec (NoteTy (SynNote ty) expansion)
- = ppr_ty env ctxt_prec ty
--- = ppr_ty env ctxt_prec expansion -- if we don't want to see syntys
-
-ppr_ty env ctxt_prec (NoteTy (FTVNote _) ty) = ppr_ty env ctxt_prec ty
-
-ppr_ty env ctxt_prec ty@(NoteTy (UsgForAll _) _)
- = maybeParen ctxt_prec fUN_PREC $
- sep [ ptext SLIT("__fuall") <+> brackets pp_uvars <+> ptext SLIT("=>"),
- ppr_ty env tOP_PREC sigma
- ]
- where
- (uvars,sigma) = splitUsForAllTys ty
- pp_uvars = hsep (map ppr uvars)
-
-ppr_ty env ctxt_prec (NoteTy (UsgNote u) ty)
- = maybeParen ctxt_prec tYCON_PREC $
- ptext SLIT("__u") <+> ppr u <+> ppr_ty env tYCON_PREC ty
-
-ppr_ty env ctxt_prec (NoteTy (IPNote nm) ty)
- = braces (ppr_pred env (IParam nm ty))
-
-ppr_theta env [] = empty
-ppr_theta env theta = braces (hsep (punctuate comma (map (ppr_pred env) theta)))
-
-ppr_pred env (Class clas tys) = ppr clas <+>
- hsep (map (ppr_ty env tYCON_PREC) tys)
-ppr_pred env (IParam n ty) = hsep [char '?' <> ppr n, text "::",
- ppr_ty env tYCON_PREC ty]
-
-{-
-ppr_dict env ctxt (clas, tys) = ppr clas <+>
- hsep (map (ppr_ty env tYCON_PREC) tys)
--}
-\end{code}
-
-\begin{code}
-pprTyEnv = initPprEnv b b (Just ppr) b (Just (\site -> pprTyVarBndr)) b
- where
- b = panic "PprType:init_ppr_env"
+instance Outputable Type where
+ ppr ty | typeKind ty `eqKind` superKind = pprKind ty
+ | otherwise = pprType ty
+
+instance Outputable PredType where
+ ppr = pprPred
+
+instance Outputable name => OutputableBndr (IPName name) where
+ pprBndr _ n = ppr n -- Simple for now
+
+instance Outputable TyThing where
+ ppr (AnId id) = ptext SLIT("AnId") <+> ppr id
+ ppr (ATyCon tc) = ptext SLIT("ATyCon") <+> ppr tc
+ ppr (AClass cl) = ptext SLIT("AClass") <+> ppr cl
+ ppr (ADataCon dc) = ptext SLIT("ADataCon") <+> ppr dc
+
+instance NamedThing TyThing where -- Can't put this with the type
+ getName (AnId id) = getName id -- decl, because the DataCon instance
+ getName (ATyCon tc) = getName tc -- isn't visible there
+ getName (AClass cl) = getName cl
+ getName (ADataCon dc) = getName dc
\end{code}
-\begin{code}
-instance Outputable UsageAnn where
- ppr UsOnce = ptext SLIT("-")
- ppr UsMany = ptext SLIT("!")
- ppr (UsVar uv) = ppr uv
-\end{code}
%************************************************************************
and when in debug mode.
\begin{code}
+pprTyVarBndr :: TyVar -> SDoc
pprTyVarBndr tyvar
= getPprStyle $ \ sty ->
- if (ifaceStyle sty || debugStyle sty) && kind /= boxedTypeKind then
+ if debugStyle sty then
hsep [ppr tyvar, dcolon, pprParendKind kind]
-- See comments with ppDcolon in PprCore.lhs
else
getTyDescription :: Type -> String
getTyDescription ty
- = case (splitSigmaTy ty) of { (_, _, tau_ty) ->
+ = case (tcSplitSigmaTy ty) of { (_, _, tau_ty) ->
case tau_ty of
- TyVarTy _ -> "*"
- AppTy fun _ -> getTyDescription fun
- FunTy _ res -> '-' : '>' : fun_result res
- TyConApp tycon _ -> getOccString tycon
+ TyVarTy _ -> "*"
+ AppTy fun _ -> getTyDescription fun
+ FunTy _ res -> '-' : '>' : fun_result res
+ NewTcApp tycon _ -> getOccString tycon
+ TyConApp tycon _ -> getOccString tycon
NoteTy (FTVNote _) ty -> getTyDescription ty
NoteTy (SynNote ty1) _ -> getTyDescription ty1
- NoteTy (UsgNote _) ty -> getTyDescription ty
- ForAllTy _ ty -> getTyDescription ty
+ PredTy sty -> getPredTyDescription sty
+ ForAllTy _ ty -> getTyDescription ty
}
where
fun_result (FunTy _ res) = '>' : fun_result res
fun_result other = getTyDescription other
+
+getPredTyDescription (ClassP cl tys) = getOccString cl
+getPredTyDescription (IParam ip ty) = getOccString (ipNameName ip)
\end{code}
= if isDictTy ty
then '+'
else
- case splitTyConApp_maybe ty of
- Nothing -> if maybeToBool (splitFunTy_maybe ty)
+ case tcSplitTyConApp_maybe ty of
+ Nothing -> if maybeToBool (tcSplitFunTy_maybe ty)
then '>'
else '.'
|| utc == addrPrimTyConKey) then 'i'
else if utc == floatPrimTyConKey then 'f'
else if utc == doublePrimTyConKey then 'd'
- else if isPrimTyCon tycon {- array, we hope -} then 'A'
+ else if isPrimTyCon tycon {- array, we hope -} then 'A' -- Bogus
else if isEnumerationTyCon tycon then 'E'
else if isTupleTyCon tycon then 'T'
else if maybeToBool (maybeTyConSingleCon tycon) then 'S'