\section[CoreLint]{A ``lint'' pass to check for Core correctness}
\begin{code}
-#include "HsVersions.h"
-
module CoreLint (
lintCoreBindings,
lintUnfolding
) where
-IMP_Ubiq()
+#include "HsVersions.h"
+import IO ( hPutStr, stderr )
+
+import CmdLineOpts ( opt_D_show_passes, opt_DoCoreLinting )
import CoreSyn
import Bag
-import Kind ( Kind{-instance-} )
+import Kind ( hasMoreBoxityInfo, Kind{-instance-} )
import Literal ( literalType, Literal{-instance-} )
-import Id ( idType, isBottomingId,
- dataConArgTys, GenId{-instances-}
+import Id ( idType, isBottomingId, dataConRepType, isDataCon, isAlgCon,
+ dataConArgTys, GenId{-instances-},
+ emptyIdSet, mkIdSet,
+ unionIdSets, elementOfIdSet, IdSet,
+ Id
)
import Maybes ( catMaybes )
-import Name ( isLocallyDefined, getSrcLoc )
-import Outputable ( Outputable(..){-instance * []-} )
+import Name ( isLocallyDefined, getSrcLoc, Name{-instance NamedThing-},
+ NamedThing(..)
+ )
import PprCore
-import PprStyle ( PprStyle(..) )
-import PprType ( GenType, GenTyVar, TyCon )
-import Pretty
-import PrimOp ( primOpType, PrimOp(..) )
+import ErrUtils ( doIfSet, ghcExit )
+import PrimOp ( primOpType )
import PrimRep ( PrimRep(..) )
+import Specialise ( idSpecVars )
import SrcLoc ( SrcLoc )
-import Type ( mkFunTy,getFunTy_maybe,mkForAllTy,mkForAllTys,getForAllTy_maybe,
- getFunTyExpandingDicts_maybe,
- getForAllTyExpandingDicts_maybe,
- isPrimType,typeKind,instantiateTy,splitSigmaTy,
- mkForAllUsageTy,getForAllUsageTy,instantiateUsage,
- maybeAppDataTyConExpandingDicts, eqTy
--- ,expandTy -- ToDo:rm
- )
-import TyCon ( isPrimTyCon )
-import TyVar ( tyVarKind, GenTyVar{-instances-} )
-import UniqSet ( emptyUniqSet, mkUniqSet, intersectUniqSets,
- unionUniqSets, elementOfUniqSet, UniqSet(..)
+import Type ( mkFunTy, splitFunTy_maybe, mkForAllTy,
+ splitForAllTy_maybe,
+ isUnpointedType, typeKind, instantiateTy,
+ splitAlgTyConApp_maybe, Type
)
+import TyCon ( TyCon, isPrimTyCon, isDataTyCon )
+import TyVar ( TyVar, tyVarKind, mkTyVarEnv )
+import ErrUtils ( ErrMsg )
import Unique ( Unique )
-import Usage ( GenUsage )
-import Util ( zipEqual, pprTrace, pprPanic, assertPanic, panic )
+import Util ( zipEqual )
+import Outputable
-infixr 9 `thenL`, `seqL`, `thenMaybeL`, `seqMaybeL`
+infixr 9 `thenL`, `seqL`, `thenMaybeL`
\end{code}
%************************************************************************
--
\begin{code}
-lintCoreBindings
- :: PprStyle -> String -> Bool -> [CoreBinding] -> [CoreBinding]
+lintCoreBindings :: String -> Bool -> [CoreBinding] -> IO ()
+
+lintCoreBindings whoDunnit spec_done binds
+ | not opt_DoCoreLinting
+ = return ()
-lintCoreBindings sty whoDunnit spec_done binds
+lintCoreBindings whoDunnit spec_done binds
= case (initL (lint_binds binds) spec_done) of
- Nothing -> binds
- Just msg ->
- pprPanic "" (ppAboves [
- ppStr ("*** Core Lint Errors: in " ++ whoDunnit ++ " ***"),
- msg sty,
- ppStr "*** Offending Program ***",
- ppAboves (map (pprCoreBinding sty) binds),
- ppStr "*** End of Offense ***"
- ])
+ Nothing -> doIfSet opt_D_show_passes
+ (hPutStr stderr ("*** Core Linted result of " ++ whoDunnit ++ "\n"))
+
+ Just bad_news -> printDump (display bad_news) >>
+ ghcExit 1
where
lint_binds [] = returnL ()
lint_binds (bind:binds)
= lintCoreBinding bind `thenL` \binders ->
addInScopeVars binders (lint_binds binds)
+
+ display bad_news
+ = vcat [
+ text ("*** Core Lint Errors: in result of " ++ whoDunnit ++ " ***"),
+ bad_news,
+ ptext SLIT("*** Offending Program ***"),
+ pprCoreBindings binds,
+ ptext SLIT("*** End of Offense ***")
+ ]
\end{code}
%************************************************************************
Nothing -> Just expr
Just msg ->
pprTrace "WARNING: Discarded bad unfolding from interface:\n"
- (ppAboves [msg PprForUser,
- ppStr "*** Bad unfolding ***",
- ppr PprDebug expr,
- ppStr "*** End unfolding ***"])
+ (vcat [msg,
+ ptext SLIT("*** Bad unfolding ***"),
+ ppr expr,
+ ptext SLIT("*** End unfolding ***")])
Nothing
\end{code}
Just ty -> checkTys (idType binder) ty (mkRhsMsg binder ty))
`seqL`
- -- Check (not isPrimType)
- checkIfSpecDoneL (not (isPrimType (idType binder)))
- (mkRhsPrimMsg binder rhs)
+ -- Check (not isUnpointedType)
+ checkIfSpecDoneL (not (isUnpointedType (idType binder)))
+ (mkRhsPrimMsg binder rhs) `seqL`
+ -- Check whether binder's specialisations contain any out-of-scope variables
+ ifSpecDoneL (mapL (checkSpecIdInScope binder) spec_vars `seqL` returnL ())
+
-- We should check the unfolding, if any, but this is tricky because
-- the unfolding is a SimplifiableCoreExpr. Give up for now.
)
+ where
+ spec_vars = idSpecVars binder
+
\end{code}
%************************************************************************
\begin{code}
lintCoreExpr :: CoreExpr -> LintM (Maybe Type) -- Nothing if error found
-lintCoreExpr (Var var) = checkInScope var `seqL` returnL (Just (idType var))
+lintCoreExpr (Var var)
+ | isAlgCon var = returnL (Just (idType var))
+ -- Micro-hack here... Class decls generate applications of their
+ -- dictionary constructor, but don't generate a binding for the
+ -- constructor (since it would never be used). After a single round
+ -- of simplification, these dictionary constructors have been
+ -- inlined (from their UnfoldInfo) to CoCons. Just between
+ -- desugaring and simplfication, though, they appear as naked, unbound
+ -- variables as the function in an application.
+ -- The hack here simply doesn't check for out-of-scope-ness for
+ -- data constructors (at least, in a function position).
+
+ | otherwise = checkIdInScope var `seqL` returnL (Just (idType var))
+
lintCoreExpr (Lit lit) = returnL (Just (literalType lit))
-lintCoreExpr (SCC _ expr) = lintCoreExpr expr
-lintCoreExpr (Coerce _ ty expr)
- = _trace "lintCoreExpr:Coerce" $
- lintCoreExpr expr `seqL` returnL (Just ty)
+
+lintCoreExpr (Note (Coerce to_ty from_ty) expr)
+ = lintCoreExpr expr `thenMaybeL` \ expr_ty ->
+ lintTy to_ty `seqL`
+ lintTy from_ty `seqL`
+ checkTys from_ty expr_ty (mkCoerceErr from_ty expr_ty) `seqL`
+ returnL (Just to_ty)
+
+lintCoreExpr (Note other_note expr)
+ = lintCoreExpr expr
lintCoreExpr (Let binds body)
= lintCoreBinding binds `thenL` \binders ->
(addInScopeVars binders (lintCoreExpr body))
lintCoreExpr e@(Con con args)
- = lintCoreArgs {-False-} e unoverloaded_ty args
+ = checkL (isDataCon con) (mkConErrMsg e) `seqL`
+ lintCoreArgs {-False-} e (dataConRepType con) args
-- Note: we don't check for primitive types in these arguments
- where
- -- Constructors are special in that they aren't passed their
- -- dictionary arguments, so we swizzle them out of the
- -- constructor type before handing over to lintCorArgs
- unoverloaded_ty = mkForAllTys tyvars tau
- (tyvars, theta, tau) = splitSigmaTy (idType con)
lintCoreExpr e@(Prim op args)
= lintCoreArgs {-True-} e (primOpType op) args
lintCoreArg e ty (LitArg lit)
= -- Make sure function type matches argument
- case (getFunTyExpandingDicts_maybe ty) of
- Just (arg,res) | (lit_ty `eqTy` arg) -> returnL(Just res)
+ case (splitFunTy_maybe ty) of
+ Just (arg,res) | (lit_ty == arg) -> returnL(Just res)
_ -> addErrL (mkAppMsg ty lit_ty e) `seqL` returnL Nothing
where
lit_ty = literalType lit
lintCoreArg e ty (VarArg v)
= -- Make sure variable is bound
- checkInScope v `seqL`
+ checkIdInScope v `seqL`
-- Make sure function type matches argument
- case (getFunTyExpandingDicts_maybe ty) of
- Just (arg,res) | (var_ty `eqTy` arg) -> returnL(Just res)
+ case (splitFunTy_maybe ty) of
+ Just (arg,res) | (var_ty == arg) -> returnL(Just res)
_ -> addErrL (mkAppMsg ty var_ty e) `seqL` returnL Nothing
where
var_ty = idType v
lintCoreArg e ty a@(TyArg arg_ty)
- = -- ToDo: Check that ty is well-kinded and has no unbound tyvars
- checkIfSpecDoneL (not (isPrimType arg_ty)) (mkSpecTyAppMsg a)
- `seqL`
- case (getForAllTyExpandingDicts_maybe ty) of
+ = lintTy arg_ty `seqL`
+
+ case (splitForAllTy_maybe ty) of
Nothing -> addErrL (mkTyAppMsg SLIT("Illegal") ty arg_ty e) `seqL` returnL Nothing
Just (tyvar,body) ->
tyvar_kind = tyVarKind tyvar
argty_kind = typeKind arg_ty
in
- if tyvar_kind == argty_kind
--- SUSPICIOUS! (tyvar_kind `isSubKindOf` argty_kind
--- || argty_kind `isSubKindOf` tyvar_kind)
+ if argty_kind `hasMoreBoxityInfo` tyvar_kind
+ -- Arg type might be boxed for a function with an uncommitted
+ -- tyvar; notably this is used so that we can give
+ -- error :: forall a:*. String -> a
+ -- and then apply it to both boxed and unboxed types.
then
- returnL(Just(instantiateTy [(tyvar,arg_ty)] body))
+ returnL(Just(instantiateTy (mkTyVarEnv [(tyvar,arg_ty)]) body))
else
- pprTrace "lintCoreArg:kinds:" (ppCat [ppr PprDebug tyvar_kind, ppr PprDebug argty_kind]) $
- addErrL (mkTyAppMsg SLIT("Kinds not right in") ty arg_ty e) `seqL` returnL Nothing
-
-lintCoreArg e ty (UsageArg u)
- = -- ToDo: Check that usage has no unbound usage variables
- case (getForAllUsageTy ty) of
- Just (uvar,bounds,body) ->
- -- ToDo: Check argument satisfies bounds
- returnL(Just(panic "lintCoreArg:instantiateUsage uvar u body"))
- _ -> addErrL (mkUsageAppMsg ty u e) `seqL` returnL Nothing
+ pprTrace "lintCoreArg:kinds:" (hsep [ppr tyvar_kind, ppr argty_kind]) $
+ addErrL (mkKindErrMsg tyvar arg_ty e) `seqL` returnL Nothing
\end{code}
%************************************************************************
where
check ty = checkTys first_ty ty (mkCaseAltMsg whole_alts)
-lintAlgAlt scrut_ty {-tycon-ToDo: use it!-} (con,args,rhs)
- = (case maybeAppDataTyConExpandingDicts scrut_ty of
- Nothing ->
- addErrL (mkAlgAltMsg1 scrut_ty)
- Just (tycon, tys_applied, cons) ->
+lintAlgAlt scrut_ty (con,args,rhs)
+ = (case splitAlgTyConApp_maybe scrut_ty of
+ Just (tycon, tys_applied, cons) | isDataTyCon tycon ->
let
arg_tys = dataConArgTys con tys_applied
in
`seqL`
mapL check (zipEqual "lintAlgAlt" arg_tys args) `seqL`
returnL ()
+
+ other -> addErrL (mkAlgAltMsg1 scrut_ty)
) `seqL`
addInScopeVars args (
lintCoreExpr rhs
%************************************************************************
%* *
+\subsection[lint-types]{Types}
+%* *
+%************************************************************************
+
+\begin{code}
+lintTy :: Type -> LintM ()
+lintTy ty = returnL ()
+-- ToDo: Check that ty is well-kinded and has no unbound tyvars
+\end{code}
+
+
+%************************************************************************
+%* *
\subsection[lint-monad]{The Lint monad}
%* *
%************************************************************************
\begin{code}
type LintM a = Bool -- True <=> specialisation has been done
-> [LintLocInfo] -- Locations
- -> UniqSet Id -- Local vars in scope
+ -> IdSet -- Local vars in scope
-> Bag ErrMsg -- Error messages so far
-> (a, Bag ErrMsg) -- Result and error messages (if any)
-type ErrMsg = PprStyle -> Pretty
-
data LintLocInfo
= RhsOf Id -- The variable bound
| LambdaBodyOf Id -- The lambda-binder
| ImportedUnfolding SrcLoc -- Some imported unfolding (ToDo: say which)
instance Outputable LintLocInfo where
- ppr sty (RhsOf v)
- = ppBesides [ppr sty (getSrcLoc v), ppStr ": [RHS of ", pp_binders sty [v], ppStr "]"]
+ ppr (RhsOf v)
+ = ppr (getSrcLoc v) <> colon <+>
+ brackets (ptext SLIT("RHS of") <+> pp_binders [v])
- ppr sty (LambdaBodyOf b)
- = ppBesides [ppr sty (getSrcLoc b),
- ppStr ": [in body of lambda with binder ", pp_binder sty b, ppStr "]"]
+ ppr (LambdaBodyOf b)
+ = ppr (getSrcLoc b) <> colon <+>
+ brackets (ptext SLIT("in body of lambda with binder") <+> pp_binder b)
- ppr sty (BodyOfLetRec bs)
- = ppBesides [ppr sty (getSrcLoc (head bs)),
- ppStr ": [in body of letrec with binders ", pp_binders sty bs, ppStr "]"]
+ ppr (BodyOfLetRec bs)
+ = ppr (getSrcLoc (head bs)) <> colon <+>
+ brackets (ptext SLIT("in body of letrec with binders") <+> pp_binders bs)
- ppr sty (ImportedUnfolding locn)
- = ppBeside (ppr sty locn) (ppStr ": [in an imported unfolding]")
+ ppr (ImportedUnfolding locn)
+ = ppr locn <> colon <+>
+ brackets (ptext SLIT("in an imported unfolding"))
-pp_binders :: PprStyle -> [Id] -> Pretty
-pp_binders sty bs = ppInterleave ppComma (map (pp_binder sty) bs)
+pp_binders :: [Id] -> SDoc
+pp_binders bs = sep (punctuate comma (map pp_binder bs))
-pp_binder :: PprStyle -> Id -> Pretty
-pp_binder sty b = ppCat [ppr sty b, ppStr "::", ppr sty (idType b)]
+pp_binder :: Id -> SDoc
+pp_binder b = hsep [ppr b, text "::", ppr (idType b)]
\end{code}
\begin{code}
initL :: LintM a -> Bool -> Maybe ErrMsg
initL m spec_done
- = case (m spec_done [] emptyUniqSet emptyBag) of { (_, errs) ->
+ = case (m spec_done [] emptyIdSet emptyBag) of { (_, errs) ->
if isEmptyBag errs then
Nothing
else
- Just ( \ sty ->
- ppAboves [ msg sty | msg <- bagToList errs ]
- )
+ Just (vcat (bagToList errs))
}
returnL :: a -> LintM a
(Nothing, errs2) -> (Nothing, errs2)
(Just r, errs2) -> k r spec loc scope errs2
-seqMaybeL :: LintM (Maybe a) -> LintM (Maybe b) -> LintM (Maybe b)
-seqMaybeL m k spec loc scope errs
- = case m spec loc scope errs of
- (Nothing, errs2) -> (Nothing, errs2)
- (Just _, errs2) -> k spec loc scope errs2
-
mapL :: (a -> LintM b) -> [a] -> LintM [b]
mapL f [] = returnL []
mapL f (x:xs)
checkIfSpecDoneL False msg True loc scope errs = ((), addErr errs msg loc)
checkIfSpecDoneL False msg False loc scope errs = ((), errs)
-addErrIfL pred spec
- = if pred then addErrL spec else returnL ()
+ifSpecDoneL :: LintM () -> LintM ()
+ifSpecDoneL m False loc scope errs = ((), errs)
+ifSpecDoneL m True loc scope errs = m True loc scope errs
addErrL :: ErrMsg -> LintM ()
addErrL msg spec loc scope errs = ((), addErr errs msg loc)
addErr errs_so_far msg locs
= ASSERT (not (null locs))
- errs_so_far `snocBag` ( \ sty ->
- ppHang (ppr sty (head locs)) 4 (msg sty)
- )
+ errs_so_far `snocBag` (hang (ppr (head locs)) 4 msg)
addLoc :: LintLocInfo -> LintM a -> LintM a
addLoc extra_loc m spec loc scope errs
-- For now, it's just a "trace"; we may make
-- a real error out of it...
let
- new_set = mkUniqSet ids
+ new_set = mkIdSet ids
- shadowed = scope `intersectUniqSets` new_set
+-- shadowed = scope `intersectIdSets` new_set
in
-- After adding -fliberate-case, Simon decided he likes shadowed
-- names after all. WDP 94/07
-- (if isEmptyUniqSet shadowed
-- then id
--- else pprTrace "Shadowed vars:" (ppr PprDebug (uniqSetToList shadowed))) (
- m spec loc (scope `unionUniqSets` new_set) errs
+-- else pprTrace "Shadowed vars:" (ppr (uniqSetToList shadowed))) (
+ m spec loc (scope `unionIdSets` new_set) errs
-- )
\end{code}
\begin{code}
-checkInScope :: Id -> LintM ()
-checkInScope id spec loc scope errs
- = if isLocallyDefined id && not (id `elementOfUniqSet` scope) then
- ((),addErr errs (\sty -> ppCat [ppr sty id,ppStr "is out of scope"]) loc)
+checkIdInScope :: Id -> LintM ()
+checkIdInScope id
+ = checkInScope (ptext SLIT("is out of scope")) id
+
+checkSpecIdInScope :: Id -> Id -> LintM ()
+checkSpecIdInScope binder id
+ = checkInScope msg id
+ where
+ msg = ptext SLIT("is out of scope inside specialisation info for") <+>
+ ppr binder
+
+checkInScope :: SDoc -> Id -> LintM ()
+checkInScope loc_msg id spec loc scope errs
+ = let
+ id_name = getName id
+ in
+ if isLocallyDefined id_name && not (id `elementOfIdSet` scope) then
+ ((), addErr errs (hsep [ppr id, loc_msg]) loc)
else
((),errs)
checkTys :: Type -> Type -> ErrMsg -> LintM ()
checkTys ty1 ty2 msg spec loc scope errs
- = if ty1 `eqTy` ty2 then ((), errs) else ((), addErr errs msg loc)
+ = if ty1 == ty2 then ((), errs) else ((), addErr errs msg loc)
\end{code}
\begin{code}
-mkCaseAltMsg :: CoreCaseAlts -> ErrMsg
-mkCaseAltMsg alts sty
- = ppAbove (ppStr "Type of case alternatives not the same:")
- (ppr sty alts)
+mkConErrMsg e
+ = ($$) (ptext SLIT("Application of newtype constructor:"))
+ (ppr e)
-mkCaseDataConMsg :: CoreExpr -> ErrMsg
-mkCaseDataConMsg expr sty
- = ppAbove (ppStr "A case scrutinee not of data constructor type:")
- (pp_expr sty expr)
-mkCaseNotPrimMsg :: TyCon -> ErrMsg
-mkCaseNotPrimMsg tycon sty
- = ppAbove (ppStr "A primitive case on a non-primitive type:")
- (ppr sty tycon)
-
-mkCasePrimMsg :: TyCon -> ErrMsg
-mkCasePrimMsg tycon sty
- = ppAbove (ppStr "An algebraic case on a primitive type:")
- (ppr sty tycon)
+mkCaseAltMsg :: CoreCaseAlts -> ErrMsg
+mkCaseAltMsg alts
+ = ($$) (ptext SLIT("Type of case alternatives not the same:"))
+ (ppr alts)
mkCaseAbstractMsg :: TyCon -> ErrMsg
-mkCaseAbstractMsg tycon sty
- = ppAbove (ppStr "An algebraic case on some weird type:")
- (ppr sty tycon)
+mkCaseAbstractMsg tycon
+ = ($$) (ptext SLIT("An algebraic case on some weird type:"))
+ (ppr tycon)
mkDefltMsg :: CoreCaseDefault -> ErrMsg
-mkDefltMsg deflt sty
- = ppAbove (ppStr "Binder in case default doesn't match type of scrutinee:")
- (ppr sty deflt)
+mkDefltMsg deflt
+ = ($$) (ptext SLIT("Binder in case default doesn't match type of scrutinee:"))
+ (ppr deflt)
mkAppMsg :: Type -> Type -> CoreExpr -> ErrMsg
-mkAppMsg fun arg expr sty
- = ppAboves [ppStr "Argument value doesn't match argument type:",
- ppHang (ppStr "Fun type:") 4 (ppr sty fun),
- ppHang (ppStr "Arg type:") 4 (ppr sty arg),
- ppHang (ppStr "Expression:") 4 (pp_expr sty expr)]
+mkAppMsg fun arg expr
+ = vcat [ptext SLIT("Argument value doesn't match argument type:"),
+ hang (ptext SLIT("Fun type:")) 4 (ppr fun),
+ hang (ptext SLIT("Arg type:")) 4 (ppr arg),
+ hang (ptext SLIT("Expression:")) 4 (pprCoreExpr expr)]
+
+mkKindErrMsg :: TyVar -> Type -> CoreExpr -> ErrMsg
+mkKindErrMsg tyvar arg_ty expr
+ = vcat [ptext SLIT("Kinds don't match in type application:"),
+ hang (ptext SLIT("Type variable:"))
+ 4 (ppr tyvar <+> ptext SLIT("::") <+> ppr (tyVarKind tyvar)),
+ hang (ptext SLIT("Arg type:"))
+ 4 (ppr arg_ty <+> ptext SLIT("::") <+> ppr (typeKind arg_ty)),
+ hang (ptext SLIT("Expression:")) 4 (pprCoreExpr expr)]
mkTyAppMsg :: FAST_STRING -> Type -> Type -> CoreExpr -> ErrMsg
-mkTyAppMsg msg ty arg expr sty
- = ppAboves [ppCat [ppPStr msg, ppStr "type application:"],
- ppHang (ppStr "Exp type:") 4 (ppr sty ty),
- ppHang (ppStr "Arg type:") 4 (ppr sty arg),
- ppHang (ppStr "Expression:") 4 (pp_expr sty expr)]
-
-mkUsageAppMsg :: Type -> Usage -> CoreExpr -> ErrMsg
-mkUsageAppMsg ty u expr sty
- = ppAboves [ppStr "Illegal usage application:",
- ppHang (ppStr "Exp type:") 4 (ppr sty ty),
- ppHang (ppStr "Usage exp:") 4 (ppr sty u),
- ppHang (ppStr "Expression:") 4 (pp_expr sty expr)]
+mkTyAppMsg msg ty arg expr
+ = vcat [hsep [ptext msg, ptext SLIT("type application:")],
+ hang (ptext SLIT("Exp type:"))
+ 4 (ppr ty <+> ptext SLIT("::") <+> ppr (typeKind ty)),
+ hang (ptext SLIT("Arg type:"))
+ 4 (ppr arg <+> ptext SLIT("::") <+> ppr (typeKind arg)),
+ hang (ptext SLIT("Expression:")) 4 (pprCoreExpr expr)]
mkAlgAltMsg1 :: Type -> ErrMsg
-mkAlgAltMsg1 ty sty
- = ppAbove (ppStr "In some case statement, type of scrutinee is not a data type:")
- (ppr sty ty)
--- (ppAbove (ppr sty ty) (ppr sty (expandTy ty))) -- ToDo: rm
+mkAlgAltMsg1 ty
+ = ($$) (text "In some case statement, type of scrutinee is not a data type:")
+ (ppr ty)
mkAlgAltMsg2 :: Type -> Id -> ErrMsg
-mkAlgAltMsg2 ty con sty
- = ppAboves [
- ppStr "In some algebraic case alternative, constructor is not a constructor of scrutinee type:",
- ppr sty ty,
- ppr sty con
+mkAlgAltMsg2 ty con
+ = vcat [
+ text "In some algebraic case alternative, constructor is not a constructor of scrutinee type:",
+ ppr ty,
+ ppr con
]
mkAlgAltMsg3 :: Id -> [Id] -> ErrMsg
-mkAlgAltMsg3 con alts sty
- = ppAboves [
- ppStr "In some algebraic case alternative, number of arguments doesn't match constructor:",
- ppr sty con,
- ppr sty alts
+mkAlgAltMsg3 con alts
+ = vcat [
+ text "In some algebraic case alternative, number of arguments doesn't match constructor:",
+ ppr con,
+ ppr alts
]
mkAlgAltMsg4 :: Type -> Id -> ErrMsg
-mkAlgAltMsg4 ty arg sty
- = ppAboves [
- ppStr "In some algebraic case alternative, type of argument doesn't match data constructor:",
- ppr sty ty,
- ppr sty arg
+mkAlgAltMsg4 ty arg
+ = vcat [
+ text "In some algebraic case alternative, type of argument doesn't match data constructor:",
+ ppr ty,
+ ppr arg
]
mkPrimAltMsg :: (Literal, CoreExpr) -> ErrMsg
-mkPrimAltMsg alt sty
- = ppAbove
- (ppStr "In a primitive case alternative, type of literal doesn't match type of scrutinee:")
- (ppr sty alt)
+mkPrimAltMsg alt
+ = ($$)
+ (text "In a primitive case alternative, type of literal doesn't match type of scrutinee:")
+ (ppr alt)
mkRhsMsg :: Id -> Type -> ErrMsg
-mkRhsMsg binder ty sty
- = ppAboves
- [ppCat [ppStr "The type of this binder doesn't match the type of its RHS:",
- ppr sty binder],
- ppCat [ppStr "Binder's type:", ppr sty (idType binder)],
- ppCat [ppStr "Rhs type:", ppr sty ty]]
+mkRhsMsg binder ty
+ = vcat
+ [hsep [ptext SLIT("The type of this binder doesn't match the type of its RHS:"),
+ ppr binder],
+ hsep [ptext SLIT("Binder's type:"), ppr (idType binder)],
+ hsep [ptext SLIT("Rhs type:"), ppr ty]]
mkRhsPrimMsg :: Id -> CoreExpr -> ErrMsg
-mkRhsPrimMsg binder rhs sty
- = ppAboves [ppCat [ppStr "The type of this binder is primitive:",
- ppr sty binder],
- ppCat [ppStr "Binder's type:", ppr sty (idType binder)]
+mkRhsPrimMsg binder rhs
+ = vcat [hsep [ptext SLIT("The type of this binder is primitive:"),
+ ppr binder],
+ hsep [ptext SLIT("Binder's type:"), ppr (idType binder)]
]
-mkSpecTyAppMsg :: CoreArg -> ErrMsg
-mkSpecTyAppMsg arg sty
- = ppAbove
- (ppStr "Unboxed types in a type application (after specialisation):")
- (ppr sty arg)
-
-pp_expr :: PprStyle -> CoreExpr -> Pretty
-pp_expr sty expr
- = pprCoreExpr sty (pprBigCoreBinder sty) (pprTypedCoreBinder sty) (pprTypedCoreBinder sty) expr
+mkCoerceErr from_ty expr_ty
+ = vcat [ptext SLIT("From-type of Coerce differs from type of enclosed expression"),
+ ptext SLIT("From-type:") <+> ppr from_ty,
+ ptext SLIT("Type of enclosed expr:") <+> ppr expr_ty
+ ]
\end{code}