%
-% (c) The GRASP/AQUA Project, Glasgow University, 1993-1995
+% (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
%
\section[CoreLint]{A ``lint'' pass to check for Core correctness}
\begin{code}
-#include "HsVersions.h"
-
module CoreLint (
lintCoreBindings,
- lintUnfolding
+ lintUnfolding,
+ beginPass, endPass
) where
-import Ubiq
+#include "HsVersions.h"
+
+import IO ( hPutStr, stderr )
+import CmdLineOpts ( opt_D_show_passes, opt_DoCoreLinting )
import CoreSyn
+import CoreUtils ( idFreeVars )
import Bag
-import Kind ( Kind{-instance-} )
-import Literal ( literalType, Literal{-instance-} )
-import Id ( idType, isBottomingId,
- getInstantiatedDataConSig, GenId{-instances-}
- )
-import Maybes ( catMaybes )
-import Outputable ( Outputable(..) )
+import Const ( Con(..), DataCon, conType, conOkForApp, conOkForAlt )
+import Id ( isConstantId, idMustBeINLINEd )
+import Var ( IdOrTyVar, Id, TyVar, idType, tyVarKind, isTyVar )
+import VarSet
+import VarEnv ( mkVarEnv )
+import Name ( isLocallyDefined, getSrcLoc )
import PprCore
-import PprStyle ( PprStyle(..) )
-import PprType ( GenType, GenTyVar, TyCon )
-import Pretty
-import PrimOp ( primOpType, PrimOp(..) )
+import ErrUtils ( doIfSet, dumpIfSet, ghcExit )
import PrimRep ( PrimRep(..) )
import SrcLoc ( SrcLoc )
-import Type ( mkFunTy,getFunTy_maybe,mkForAllTy,getForAllTy_maybe,
- isPrimType,getTypeKind,instantiateTy,
- mkForAllUsageTy,getForAllUsageTy,instantiateUsage,
- maybeAppDataTyCon, eqTy
- )
-import TyCon ( isPrimTyCon, tyConFamilySize )
-import TyVar ( getTyVarKind, GenTyVar{-instances-} )
-import UniqSet ( emptyUniqSet, mkUniqSet, intersectUniqSets,
- unionUniqSets, elementOfUniqSet, UniqSet(..)
+import Type ( Type, Kind, tyVarsOfType,
+ splitFunTy_maybe, mkPiType, mkTyVarTy,
+ splitForAllTy_maybe, splitTyConApp_maybe,
+ isUnLiftedType, typeKind, substTy,
+ splitAlgTyConApp_maybe,
+ isUnboxedTupleType,
+ hasMoreBoxityInfo
)
-import Unique ( Unique )
-import Usage ( GenUsage )
-import Util ( zipEqual, pprTrace, pprPanic, assertPanic, panic )
+import TyCon ( TyCon, isPrimTyCon, tyConDataCons )
+import ErrUtils ( ErrMsg )
+import Outputable
-infixr 9 `thenL`, `seqL`, `thenMaybeL`, `seqMaybeL`
+infixr 9 `thenL`, `seqL`, `thenMaybeL`
\end{code}
%************************************************************************
%* *
+\subsection{Start and end pass}
+%* *
+%************************************************************************
+
+@beginPass@ and @endPass@ don't really belong here, but it makes a convenient
+place for them. They print out stuff before and after core passes,
+and do Core Lint when necessary.
+
+\begin{code}
+beginPass :: String -> IO ()
+beginPass pass_name
+ | opt_D_show_passes
+ = hPutStr stderr ("*** " ++ pass_name ++ "\n")
+ | otherwise
+ = return ()
+
+
+endPass :: String -> Bool -> [CoreBind] -> IO [CoreBind]
+endPass pass_name dump_flag binds
+ = do
+ -- Report verbosely, if required
+ dumpIfSet dump_flag pass_name
+ (pprCoreBindings binds)
+
+ -- Type check
+ lintCoreBindings pass_name binds
+
+ return binds
+\end{code}
+
+
+%************************************************************************
+%* *
\subsection[lintCoreBindings]{@lintCoreBindings@: Top-level interface}
%* *
%************************************************************************
--
-- * Oversaturated type app after specialisation (eta reduction
-- may well be happening...);
- --
- -- Note: checkTyApp is usually followed by a call to checkSpecTyApp.
- --
\begin{code}
-lintCoreBindings
- :: PprStyle -> String -> Bool -> [CoreBinding] -> [CoreBinding]
+lintCoreBindings :: String -> [CoreBind] -> IO ()
-lintCoreBindings sty 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 ***"
- ])
+lintCoreBindings whoDunnit binds
+ | not opt_DoCoreLinting
+ = return ()
+
+lintCoreBindings whoDunnit binds
+ = case (initL (lint_binds binds)) of
+ 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}
%************************************************************************
lintUnfolding locn expr
= case
- (initL (addLoc (ImportedUnfolding locn) (lintCoreExpr expr))
- True{-pretend spec done-})
+ initL (addLoc (ImportedUnfolding locn) (lintCoreExpr expr))
of
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}
Check a core binding, returning the list of variables bound.
\begin{code}
-lintCoreBinding :: CoreBinding -> LintM [Id]
+lintCoreBinding :: CoreBind -> LintM [Id]
lintCoreBinding (NonRec binder rhs)
= lintSingleBinding (binder,rhs) `seqL` returnL [binder]
mapL lintSingleBinding pairs `seqL` returnL binders
)
where
- binders = [b | (b,_) <- pairs]
+ binders = map fst pairs
lintSingleBinding (binder,rhs)
- = addLoc (RhsOf binder) (
+ = addLoc (RhsOf binder) $
+
-- Check the rhs
- lintCoreExpr rhs
+ lintCoreExpr rhs `thenL` \ ty ->
- `thenL` \maybe_ty ->
-- Check match to RHS type
- (case maybe_ty of
- Nothing -> returnL ()
- Just ty -> checkTys (idType binder) ty (mkRhsMsg binder ty))
+ lintBinder binder `seqL`
+ checkTys binder_ty ty (mkRhsMsg binder ty) `seqL`
- `seqL`
- -- Check (not isPrimType)
- checkIfSpecDoneL (not (isPrimType (idType binder)))
- (mkRhsPrimMsg binder rhs)
+ -- Check (not isUnLiftedType) (also checks for bogus unboxed tuples)
+ checkL (not (isUnLiftedType binder_ty))
+ (mkRhsPrimMsg binder rhs) `seqL`
+ -- Check whether binder's specialisations contain any out-of-scope variables
+ mapL (checkBndrIdInScope binder) bndr_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
+ binder_ty = idType binder
+ bndr_vars = varSetElems (idFreeVars 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 (Lit lit) = returnL (Just (literalType lit))
-lintCoreExpr (SCC _ expr) = lintCoreExpr expr
+lintCoreExpr :: CoreExpr -> LintM Type
+
+lintCoreExpr (Var var)
+ | isConstantId var = returnL (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).
+ -- Ditto primitive Ids
+
+ | otherwise = checkIdInScope var `seqL` returnL (idType var)
+
+lintCoreExpr (Note (Coerce to_ty from_ty) expr)
+ = lintCoreExpr expr `thenL` \ expr_ty ->
+ lintTy to_ty `seqL`
+ lintTy from_ty `seqL`
+ checkTys from_ty expr_ty (mkCoerceErr from_ty expr_ty) `seqL`
+ returnL 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 (idType con) args
- -- Note: we don't check for primitive types in these arguments
-
-lintCoreExpr e@(Prim op args)
- = lintCoreArgs True e (primOpType op) args
- -- Note: we do check for primitive types in these arguments
-
-lintCoreExpr e@(App fun@(Var v) arg) | isBottomingId v
- = lintCoreExpr fun `thenMaybeL` \ ty -> lintCoreArg False e ty arg
- -- Note: we don't check for primitive types in argument to 'error'
+ = addLoc (AnExpr e) $
+ checkL (conOkForApp con) (mkConAppMsg e) `seqL`
+ lintCoreArgs (conType con) args
lintCoreExpr e@(App fun arg)
- = lintCoreExpr fun `thenMaybeL` \ty -> lintCoreArg True e ty arg
- -- Note: we do check for primitive types in this argument
-
-lintCoreExpr (Lam (ValBinder var) expr)
- = addLoc (LambdaBodyOf var)
- (addInScopeVars [var]
- (lintCoreExpr expr `thenMaybeL` \ty ->
- returnL (Just (mkFunTy (idType var) ty))))
-
-lintCoreExpr (Lam (TyBinder tyvar) expr)
- = lintCoreExpr expr `thenMaybeL` \ty ->
- returnL (Just(mkForAllTy tyvar ty))
- -- TODO: Should add in-scope type variable at this point
-
-lintCoreExpr e@(Case scrut alts)
- = lintCoreExpr scrut `thenMaybeL` \ty ->
- -- Check that it is a data type
- case maybeAppDataTyCon ty of
- Nothing -> addErrL (mkCaseDataConMsg e) `seqL` returnL Nothing
- Just(tycon, _, _) -> lintCoreAlts alts ty tycon
+ = lintCoreExpr fun `thenL` \ ty ->
+ addLoc (AnExpr e) $
+ lintCoreArg ty arg
+
+lintCoreExpr (Lam var expr)
+ = addLoc (LambdaBodyOf var) $
+ checkL (not (isUnboxedTupleType (idType var))) (mkUnboxedTupleMsg var)
+ `seqL`
+ (addInScopeVars [var] $
+ lintCoreExpr expr `thenL` \ ty ->
+ returnL (mkPiType var ty))
+
+lintCoreExpr e@(Case scrut var alts)
+ = -- Check the scrutinee
+ lintCoreExpr scrut `thenL` \ scrut_ty ->
+
+ -- Check the binder
+ lintBinder var `seqL`
+
+ -- If this is an unboxed tuple case, then the binder must be dead
+ {-
+ checkL (if isUnboxedTupleType (idType var)
+ then isDeadBinder var
+ else True) (mkUnboxedTupleMsg var) `seqL`
+ -}
+
+ checkTys (idType var) scrut_ty (mkScrutMsg var scrut_ty) `seqL`
+
+ addInScopeVars [var] (
+
+ -- Check the alternatives
+ checkAllCasesCovered e scrut_ty alts `seqL`
+ mapL (lintCoreAlt scrut_ty) alts `thenL` \ (alt_ty : alt_tys) ->
+ mapL (check alt_ty) alt_tys `seqL`
+ returnL alt_ty)
+ where
+ check alt_ty1 alt_ty2 = checkTys alt_ty1 alt_ty2 (mkCaseAltMsg e)
\end{code}
%************************************************************************
applications to primitive types as being errors.
\begin{code}
-lintCoreArgs :: Bool -> CoreExpr -> Type -> [CoreArg] -> LintM (Maybe Type)
+lintCoreArgs :: Type -> [CoreArg] -> LintM Type
-lintCoreArgs _ _ ty [] = returnL (Just ty)
-lintCoreArgs checkTyApp e ty (a : args)
- = lintCoreArg checkTyApp e ty a `thenMaybeL` \ res ->
- lintCoreArgs checkTyApp e res args
+lintCoreArgs ty [] = returnL ty
+lintCoreArgs ty (a : args)
+ = lintCoreArg ty a `thenL` \ res ->
+ lintCoreArgs res args
+\end{code}
+
+\begin{code}
+lintCoreArg :: Type -> CoreArg -> LintM Type
+
+lintCoreArg ty a@(Type arg_ty)
+ = lintTy arg_ty `seqL`
+ lintTyApp ty arg_ty
+
+lintCoreArg fun_ty arg
+ = -- Make sure function type matches argument
+ lintCoreExpr arg `thenL` \ arg_ty ->
+ case (splitFunTy_maybe fun_ty) of
+ Just (arg,res) | (arg_ty == arg) -> returnL res
+ _ -> addErrL (mkAppMsg fun_ty arg_ty)
\end{code}
+\begin{code}
+lintTyApp ty arg_ty
+ = case splitForAllTy_maybe ty of
+ Nothing -> addErrL (mkTyAppMsg ty arg_ty)
+
+ Just (tyvar,body) ->
+ let
+ tyvar_kind = tyVarKind tyvar
+ argty_kind = typeKind arg_ty
+ in
+ 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 (substTy (mkVarEnv [(tyvar,arg_ty)]) body)
+ else
+ addErrL (mkKindErrMsg tyvar arg_ty)
+
+lintTyApps fun_ty []
+ = returnL fun_ty
+
+lintTyApps fun_ty (arg_ty : arg_tys)
+ = lintTyApp fun_ty arg_ty `thenL` \ fun_ty' ->
+ lintTyApps fun_ty' arg_tys
+\end{code}
+
+
+
%************************************************************************
%* *
-\subsection[lintCoreArg]{lintCoreArg}
+\subsection[lintCoreAlts]{lintCoreAlts}
%* *
%************************************************************************
\begin{code}
-lintCoreArg :: Bool -> CoreExpr -> Type -> CoreArg -> LintM (Maybe Type)
+checkAllCasesCovered e ty [] = addErrL (mkNullAltsMsg e)
-lintCoreArg _ e ty (LitArg lit)
- = -- Make sure function type matches argument
- case (getFunTy_maybe ty) of
- Just (arg,res) | (literalType lit `eqTy` arg) -> returnL(Just res)
- _ -> addErrL (mkAppMsg ty (literalType lit) e) `seqL` returnL Nothing
-
-lintCoreArg _ e ty (VarArg v)
- = -- Make sure variable is bound
- checkInScope v `seqL`
- -- Make sure function type matches argument
- case (getFunTy_maybe ty) of
- Just (arg,res) | (idType v `eqTy` arg) -> returnL(Just res)
- _ -> addErrL (mkAppMsg ty (idType v) e) `seqL` returnL Nothing
-
-lintCoreArg checkTyApp 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 (getForAllTy_maybe ty) of
- Just (tyvar,body) | (getTyVarKind tyvar == getTypeKind arg_ty) ->
- returnL(Just(instantiateTy [(tyvar,arg_ty)] body))
- _ -> addErrL (mkTyAppMsg 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
+checkAllCasesCovered e ty [(DEFAULT,_,_)] = nopL
+
+checkAllCasesCovered e scrut_ty alts
+ = case splitTyConApp_maybe scrut_ty of {
+ Nothing -> addErrL (badAltsMsg e);
+ Just (tycon, tycon_arg_tys) ->
+
+ if isPrimTyCon tycon then
+ checkL (hasDefault alts) (nonExhaustiveAltsMsg e)
+ else
+#ifdef DEBUG
+ -- Algebraic cases are not necessarily exhaustive, because
+ -- the simplifer correctly eliminates case that can't
+ -- possibly match.
+ -- This code just emits a message to say so
+ let
+ missing_cons = filter not_in_alts (tyConDataCons tycon)
+ not_in_alts con = all (not_in_alt con) alts
+ not_in_alt con (DataCon con', _, _) = con /= con'
+ not_in_alt con other = True
+
+ case_bndr = case e of { Case _ bndr alts -> bndr }
+ in
+ if not (hasDefault alts || null missing_cons) then
+ pprTrace "Exciting (but not a problem)! Non-exhaustive case:"
+ (ppr case_bndr <+> ppr missing_cons)
+ nopL
+ else
+#endif
+ nopL }
+
+hasDefault [] = False
+hasDefault ((DEFAULT,_,_) : alts) = True
+hasDefault (alt : alts) = hasDefault alts
+\end{code}
+
+\begin{code}
+lintCoreAlt :: Type -- Type of scrutinee
+ -> CoreAlt
+ -> LintM Type -- Type of alternatives
+
+lintCoreAlt scrut_ty alt@(DEFAULT, args, rhs)
+ = checkL (null args) (mkDefaultArgsMsg args) `seqL`
+ lintCoreExpr rhs
+
+lintCoreAlt scrut_ty alt@(con, args, rhs)
+ = addLoc (CaseAlt alt) (
+
+ checkL (conOkForAlt con) (mkConAltMsg con) `seqL`
+
+ mapL (\arg -> checkL (not (isUnboxedTupleType (idType arg)))
+ (mkUnboxedTupleMsg arg)) args `seqL`
+
+ addInScopeVars args (
+
+ -- Check the pattern
+ -- Scrutinee type must be a tycon applicn; checked by caller
+ -- This code is remarkably compact considering what it does!
+ -- NB: args must be in scope here so that the lintCoreArgs line works.
+ case splitTyConApp_maybe scrut_ty of { Just (tycon, tycon_arg_tys) ->
+ lintTyApps (conType con) tycon_arg_tys `thenL` \ con_type ->
+ lintCoreArgs con_type (map mk_arg args) `thenL` \ con_result_ty ->
+ checkTys con_result_ty scrut_ty (mkBadPatMsg con_result_ty scrut_ty)
+ } `seqL`
+
+ -- Check the RHS
+ lintCoreExpr rhs
+ ))
+ where
+ mk_arg b | isTyVar b = Type (mkTyVarTy b)
+ | otherwise = Var b
\end{code}
%************************************************************************
%* *
-\subsection[lintCoreAlts]{lintCoreAlts}
+\subsection[lint-types]{Types}
%* *
%************************************************************************
\begin{code}
-lintCoreAlts :: CoreCaseAlts
- -> Type -- Type of scrutinee
- -> TyCon -- TyCon pinned on the case
- -> LintM (Maybe Type) -- Type of alternatives
-
-lintCoreAlts whole_alts@(AlgAlts alts deflt) ty tycon
- = -- Check tycon is not a primitive tycon
- addErrIfL (isPrimTyCon tycon) (mkCasePrimMsg tycon)
- `seqL`
- -- Check we are scrutinising a proper datatype
- -- (ToDo: robustify)
- addErrIfL (not (tyConFamilySize tycon >= 1)) (mkCaseAbstractMsg tycon)
- `seqL`
- lintDeflt deflt ty
- `thenL` \maybe_deflt_ty ->
- mapL (lintAlgAlt ty tycon) alts
- `thenL` \maybe_alt_tys ->
- -- Check the result types
- case catMaybes (maybe_deflt_ty : maybe_alt_tys) of
- [] -> returnL Nothing
-
- (first_ty:tys) -> mapL check tys `seqL`
- returnL (Just first_ty)
- where
- check ty = checkTys first_ty ty (mkCaseAltMsg whole_alts)
-
-lintCoreAlts whole_alts@(PrimAlts alts deflt) ty tycon
- = -- Check tycon is a primitive tycon
- addErrIfL (not (isPrimTyCon tycon)) (mkCaseNotPrimMsg tycon)
- `seqL`
- mapL (lintPrimAlt ty) alts
- `thenL` \maybe_alt_tys ->
- lintDeflt deflt ty
- `thenL` \maybe_deflt_ty ->
- -- Check the result types
- case catMaybes (maybe_deflt_ty : maybe_alt_tys) of
- [] -> returnL Nothing
-
- (first_ty:tys) -> mapL check tys `seqL`
- returnL (Just first_ty)
- where
- check ty = checkTys first_ty ty (mkCaseAltMsg whole_alts)
-
-lintAlgAlt scrut_ty tycon{-ToDo: use it!-} (con,args,rhs)
- = (case maybeAppDataTyCon scrut_ty of
- Nothing ->
- addErrL (mkAlgAltMsg1 scrut_ty)
- Just (tycon, tys_applied, cons) ->
- let
- (_, arg_tys, _) = getInstantiatedDataConSig con tys_applied
- in
- checkL (con `elem` cons) (mkAlgAltMsg2 scrut_ty con) `seqL`
- checkL (length arg_tys == length args) (mkAlgAltMsg3 con args)
- `seqL`
- mapL check (arg_tys `zipEqual` args) `seqL`
- returnL ()
- ) `seqL`
- addInScopeVars args (
- lintCoreExpr rhs
- )
- where
- check (ty, arg) = checkTys ty (idType arg) (mkAlgAltMsg4 ty arg)
-
- -- elem: yes, the elem-list here can sometimes be long-ish,
- -- but as it's use-once, probably not worth doing anything different
- -- We give it its own copy, so it isn't overloaded.
- elem _ [] = False
- elem x (y:ys) = x==y || elem x ys
-
-lintPrimAlt ty alt@(lit,rhs)
- = checkTys (literalType lit) ty (mkPrimAltMsg alt) `seqL`
- lintCoreExpr rhs
-
-lintDeflt NoDefault _ = returnL Nothing
-lintDeflt deflt@(BindDefault binder rhs) ty
- = checkTys (idType binder) ty (mkDefltMsg deflt) `seqL`
- addInScopeVars [binder] (lintCoreExpr rhs)
+lintBinder :: IdOrTyVar -> LintM ()
+lintBinder v = nopL
+-- ToDo: lint its type
+
+lintTy :: Type -> LintM ()
+lintTy ty = mapL checkIdInScope (varSetElems (tyVarsOfType ty)) `seqL`
+ returnL ()
+ -- ToDo: check the kind structure of the type
\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
+type LintM a = [LintLocInfo] -- Locations
+ -> IdSet -- Local vars in scope
-> Bag ErrMsg -- Error messages so far
- -> (a, Bag ErrMsg) -- Result and error messages (if any)
-
-type ErrMsg = PprStyle -> Pretty
+ -> (Maybe a, Bag ErrMsg) -- Result and error messages (if any)
data LintLocInfo
= RhsOf Id -- The variable bound
| LambdaBodyOf Id -- The lambda-binder
| BodyOfLetRec [Id] -- One of the binders
+ | CaseAlt CoreAlt -- Pattern of a case alternative
+ | AnExpr CoreExpr -- Some expression
| 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 sty (LambdaBodyOf b)
- = ppBesides [ppr sty (getSrcLoc b),
- ppStr ": [in body of lambda with binder ", pp_binder sty b, ppStr "]"]
-
- ppr sty (BodyOfLetRec bs)
- = ppBesides [ppr sty (getSrcLoc (head bs)),
- ppStr ": [in body of letrec with binders ", pp_binders sty bs, ppStr "]"]
-
- ppr sty (ImportedUnfolding locn)
- = ppBeside (ppr sty locn) (ppStr ": [in an imported unfolding]")
-
-pp_binders :: PprStyle -> [Id] -> Pretty
-pp_binders sty bs = ppInterleave ppComma (map (pp_binder sty) bs)
-
-pp_binder :: PprStyle -> Id -> Pretty
-pp_binder sty b = ppCat [ppr sty b, ppStr "::", ppr sty (idType b)]
\end{code}
\begin{code}
-initL :: LintM a -> Bool -> Maybe ErrMsg
-initL m spec_done
- = case (m spec_done [] emptyUniqSet emptyBag) of { (_, errs) ->
+initL :: LintM a -> Maybe ErrMsg
+initL m
+ = case (m [] emptyVarSet 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
-returnL r spec loc scope errs = (r, errs)
+returnL r loc scope errs = (Just r, errs)
+
+nopL :: LintM a
+nopL loc scope errs = (Nothing, errs)
thenL :: LintM a -> (a -> LintM b) -> LintM b
-thenL m k spec loc scope errs
- = case m spec loc scope errs of
- (r, errs') -> k r spec loc scope errs'
+thenL m k loc scope errs
+ = case m loc scope errs of
+ (Just r, errs') -> k r loc scope errs'
+ (Nothing, errs') -> (Nothing, errs')
seqL :: LintM a -> LintM b -> LintM b
-seqL m k spec loc scope errs
- = case m spec loc scope errs of
- (_, errs') -> k spec loc scope errs'
-
-thenMaybeL :: LintM (Maybe a) -> (a -> LintM (Maybe b)) -> LintM (Maybe b)
-thenMaybeL m k spec loc scope errs
- = case m spec loc scope errs of
- (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
+seqL m k loc scope errs
+ = case m loc scope errs of
+ (_, errs') -> k loc scope errs'
mapL :: (a -> LintM b) -> [a] -> LintM [b]
mapL f [] = returnL []
= f x `thenL` \ r ->
mapL f xs `thenL` \ rs ->
returnL (r:rs)
-
-mapMaybeL :: (a -> LintM (Maybe b)) -> [a] -> LintM (Maybe [b])
- -- Returns Nothing if anything fails
-mapMaybeL f [] = returnL (Just [])
-mapMaybeL f (x:xs)
- = f x `thenMaybeL` \ r ->
- mapMaybeL f xs `thenMaybeL` \ rs ->
- returnL (Just (r:rs))
\end{code}
\begin{code}
checkL :: Bool -> ErrMsg -> LintM ()
-checkL True msg spec loc scope errs = ((), errs)
-checkL False msg spec loc scope errs = ((), addErr errs msg loc)
-
-checkIfSpecDoneL :: Bool -> ErrMsg -> LintM ()
-checkIfSpecDoneL True msg spec loc scope errs = ((), errs)
-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 ()
+checkL True msg loc scope errs = (Nothing, errs)
+checkL False msg loc scope errs = (Nothing, addErr errs msg loc)
-addErrL :: ErrMsg -> LintM ()
-addErrL msg spec loc scope errs = ((), addErr errs msg loc)
+addErrL :: ErrMsg -> LintM a
+addErrL msg loc scope errs = (Nothing, addErr errs msg loc)
addErr :: Bag ErrMsg -> ErrMsg -> [LintLocInfo] -> Bag ErrMsg
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 (pprLoc (head locs)) 4 msg)
addLoc :: LintLocInfo -> LintM a -> LintM a
-addLoc extra_loc m spec loc scope errs
- = m spec (extra_loc:loc) scope errs
-
-addInScopeVars :: [Id] -> LintM a -> LintM a
-addInScopeVars ids m spec loc scope errs
- = -- We check if these "new" ids are already
- -- in scope, i.e., we have *shadowing* going on.
- -- For now, it's just a "trace"; we may make
- -- a real error out of it...
- let
- new_set = mkUniqSet ids
+addLoc extra_loc m loc scope errs
+ = m (extra_loc:loc) scope errs
- shadowed = scope `intersectUniqSets` 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
--- )
+addInScopeVars :: [IdOrTyVar] -> LintM a -> LintM a
+addInScopeVars ids m loc scope errs
+ = m loc (scope `unionVarSet` mkVarSet ids) 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)
- else
- ((),errs)
+checkIdInScope :: IdOrTyVar -> LintM ()
+checkIdInScope id
+ = checkInScope (ptext SLIT("is out of scope")) id
+
+checkBndrIdInScope :: IdOrTyVar -> IdOrTyVar -> LintM ()
+checkBndrIdInScope binder id
+ = checkInScope msg id
+ where
+ msg = ptext SLIT("is out of scope inside info for") <+>
+ ppr binder
+
+checkInScope :: SDoc -> IdOrTyVar -> LintM ()
+checkInScope loc_msg id loc scope errs
+ | isLocallyDefined id
+ && not (id `elemVarSet` scope)
+ && not (idMustBeINLINEd id) -- Constructors and dict selectors
+ -- don't have bindings,
+ -- just MustInline prags
+ = (Nothing, addErr errs (hsep [ppr id, loc_msg]) loc)
+ | otherwise
+ = (Nothing,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)
+checkTys ty1 ty2 msg loc scope errs
+ | ty1 == ty2 = (Nothing, errs)
+ | otherwise = (Nothing, addErr errs msg loc)
\end{code}
+
+%************************************************************************
+%* *
+\subsection{Error messages}
+%* *
+%************************************************************************
+
\begin{code}
-mkCaseAltMsg :: CoreCaseAlts -> ErrMsg
-mkCaseAltMsg alts sty
- = ppAbove (ppStr "Type of case alternatives not the same:")
- (ppr sty alts)
-
-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)
-
-mkCaseAbstractMsg :: TyCon -> ErrMsg
-mkCaseAbstractMsg tycon sty
- = ppAbove (ppStr "An algebraic case on some weird type:")
- (ppr sty tycon)
-
-mkDefltMsg :: CoreCaseDefault -> ErrMsg
-mkDefltMsg deflt sty
- = ppAbove (ppStr "Binder in case default doesn't match type of scrutinee:")
- (ppr sty deflt)
-
-mkAppMsg :: Type -> Type -> CoreExpr -> ErrMsg
-mkAppMsg fun arg expr sty
- = ppAboves [ppStr "Argument values 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)]
-
-mkTyAppMsg :: Type -> Type -> CoreExpr -> ErrMsg
-mkTyAppMsg ty arg expr sty
- = panic "mkTyAppMsg"
-{-
- = ppAboves [ppStr "Illegal type application:",
- ppHang (ppStr "Exp type:") 4 (ppr sty exp),
- 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)]
-
-mkAlgAltMsg1 :: Type -> ErrMsg
-mkAlgAltMsg1 ty sty
- = ppAbove (ppStr "In some case statement, type of scrutinee is not a data type:")
- (ppr sty 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
- ]
+pprLoc (RhsOf v)
+ = ppr (getSrcLoc v) <> colon <+>
+ brackets (ptext SLIT("RHS of") <+> pp_binders [v])
-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
- ]
+pprLoc (LambdaBodyOf b)
+ = ppr (getSrcLoc b) <> colon <+>
+ brackets (ptext SLIT("in body of lambda with binder") <+> pp_binder b)
+
+pprLoc (BodyOfLetRec bs)
+ = ppr (getSrcLoc (head bs)) <> colon <+>
+ brackets (ptext SLIT("in body of letrec with binders") <+> pp_binders bs)
+
+pprLoc (AnExpr e)
+ = text "In the expression:" <+> ppr e
+
+pprLoc (CaseAlt (con, args, rhs))
+ = text "In a case pattern:" <+> parens (ppr con <+> ppr args)
-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
+pprLoc (ImportedUnfolding locn)
+ = ppr locn <> colon <+>
+ brackets (ptext SLIT("in an imported unfolding"))
+
+pp_binders :: [Id] -> SDoc
+pp_binders bs = sep (punctuate comma (map pp_binder bs))
+
+pp_binder :: Id -> SDoc
+pp_binder b = hsep [ppr b, text "::", ppr (idType b)]
+\end{code}
+
+\begin{code}
+------------------------------------------------------
+-- Messages for case expressions
+
+mkConAppMsg :: CoreExpr -> ErrMsg
+mkConAppMsg e
+ = hang (text "Application of newtype constructor:")
+ 4 (ppr e)
+
+mkConAltMsg :: Con -> ErrMsg
+mkConAltMsg con
+ = text "PrimOp in case pattern:" <+> ppr con
+
+mkNullAltsMsg :: CoreExpr -> ErrMsg
+mkNullAltsMsg e
+ = hang (text "Case expression with no alternatives:")
+ 4 (ppr e)
+
+mkDefaultArgsMsg :: [IdOrTyVar] -> ErrMsg
+mkDefaultArgsMsg args
+ = hang (text "DEFAULT case with binders")
+ 4 (ppr args)
+
+mkCaseAltMsg :: CoreExpr -> ErrMsg
+mkCaseAltMsg e
+ = hang (text "Type of case alternatives not the same:")
+ 4 (ppr e)
+
+mkScrutMsg :: Id -> Type -> ErrMsg
+mkScrutMsg var scrut_ty
+ = vcat [text "Result binder in case doesn't match scrutinee:" <+> ppr var,
+ text "Result binder type:" <+> ppr (idType var),
+ text "Scrutinee type:" <+> ppr scrut_ty]
+
+badAltsMsg :: CoreExpr -> ErrMsg
+badAltsMsg e
+ = hang (text "Case statement scrutinee is not a data type:")
+ 4 (ppr e)
+
+nonExhaustiveAltsMsg :: CoreExpr -> ErrMsg
+nonExhaustiveAltsMsg e
+ = hang (text "Case expression with non-exhaustive alternatives")
+ 4 (ppr e)
+
+mkBadPatMsg :: Type -> Type -> ErrMsg
+mkBadPatMsg con_result_ty scrut_ty
+ = vcat [
+ text "In a case alternative, pattern result type doesn't match scrutinee type:",
+ text "Pattern result type:" <+> ppr con_result_ty,
+ text "Scrutinee type:" <+> ppr scrut_ty
]
-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)
+------------------------------------------------------
+-- Other error messages
+
+mkAppMsg :: Type -> Type -> ErrMsg
+mkAppMsg fun arg
+ = 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)]
+
+mkKindErrMsg :: TyVar -> Type -> ErrMsg
+mkKindErrMsg tyvar arg_ty
+ = 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))]
+
+mkTyAppMsg :: Type -> Type -> ErrMsg
+mkTyAppMsg ty arg_ty
+ = vcat [text "Illegal type application:",
+ hang (ptext SLIT("Exp type:"))
+ 4 (ppr ty <+> ptext SLIT("::") <+> ppr (typeKind ty)),
+ hang (ptext SLIT("Arg type:"))
+ 4 (ppr arg_ty <+> ptext SLIT("::") <+> ppr (typeKind arg_ty))]
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)
+mkUnboxedTupleMsg :: Id -> ErrMsg
+mkUnboxedTupleMsg binder
+ = vcat [hsep [ptext SLIT("A variable has unboxed tuple type:"), ppr binder],
+ hsep [ptext SLIT("Binder's type:"), ppr (idType binder)]]
-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}
projects / ghc-hetmet.git / blobdiff