%
-% (c) The GRASP/AQUA Project, Glasgow University, 1993-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
%
\section[CoreLint]{A ``lint'' pass to check for Core correctness}
\begin{code}
module CoreLint (
lintCoreBindings,
- lintUnfolding
+ lintUnfolding,
+ showPass, endPass
) where
#include "HsVersions.h"
-import IO ( hPutStr, stderr )
-
-import CmdLineOpts ( opt_D_show_passes, opt_DoCoreLinting )
import CoreSyn
-import CoreUtils ( idSpecVars )
+import CoreFVs ( idFreeVars )
+import CoreUtils ( findDefault, exprOkForSpeculation, coreBindsSize, mkPiType )
import Bag
-import Kind ( hasMoreBoxityInfo, Kind{-instance-} )
-import Literal ( literalType, Literal{-instance-} )
-import Id ( idType, isBottomingId, dataConRepType, isDataCon, isAlgCon,
- dataConArgTys, GenId{-instances-},
- emptyIdSet, mkIdSet,
- unionIdSets, elementOfIdSet, IdSet,
- Id
- )
-import Maybes ( catMaybes )
-import Name ( isLocallyDefined, getSrcLoc, Name{-instance NamedThing-},
- NamedThing(..)
- )
+import Literal ( literalType )
+import DataCon ( dataConRepType )
+import Var ( Var, Id, TyVar, idType, tyVarKind, isTyVar, isId, mustHaveLocalBinding )
+import VarSet
+import Subst ( substTyWith )
+import Name ( getSrcLoc )
import PprCore
-import ErrUtils ( doIfSet, ghcExit )
-import PrimOp ( primOpType )
-import PrimRep ( PrimRep(..) )
-import SrcLoc ( SrcLoc )
-import Type ( mkFunTy, splitFunTy_maybe, mkForAllTy,
- splitForAllTy_maybe, tyVarsOfType,
- isUnpointedType, typeKind, instantiateTy,
- splitAlgTyConApp_maybe, Type
- )
-import TyCon ( TyCon, isPrimTyCon, isDataTyCon )
-import TyVar ( TyVar, tyVarKind, mkTyVarEnv,
- TyVarSet,
- emptyTyVarSet, mkTyVarSet, isEmptyTyVarSet,
- minusTyVarSet, elementOfTyVarSet, tyVarSetToList,
- unionTyVarSets, intersectTyVarSets
+import ErrUtils ( dumpIfSet_core, ghcExit, Message, showPass,
+ addErrLocHdrLine )
+import SrcLoc ( SrcLoc, noSrcLoc )
+import Type ( Type, tyVarsOfType, eqType,
+ splitFunTy_maybe, mkTyVarTy,
+ splitForAllTy_maybe, splitTyConApp_maybe, splitTyConApp,
+ isUnLiftedType, typeKind,
+ isUnboxedTupleType,
+ hasMoreBoxityInfo
)
-import ErrUtils ( ErrMsg )
-import Unique ( Unique )
-import Util ( zipEqual )
+import TyCon ( isPrimTyCon )
+import BasicTypes ( RecFlag(..), isNonRec )
+import CmdLineOpts
+import Maybe
import Outputable
-infixr 9 `thenL`, `seqL`, `thenMaybeL`
+import IO ( hPutStrLn, stderr )
+
+infixr 9 `thenL`, `seqL`
\end{code}
%************************************************************************
%* *
+\subsection{End pass}
+%* *
+%************************************************************************
+
+@showPass@ 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}
+endPass :: DynFlags -> String -> DynFlag -> [CoreBind] -> IO [CoreBind]
+endPass dflags pass_name dump_flag binds
+ = do
+ -- Report result size if required
+ -- This has the side effect of forcing the intermediate to be evaluated
+ if verbosity dflags >= 2 then
+ hPutStrLn stderr (" Result size = " ++ show (coreBindsSize binds))
+ else
+ return ()
+
+ -- Report verbosely, if required
+ dumpIfSet_core dflags dump_flag pass_name (pprCoreBindings binds)
+
+ -- Type check
+ lintCoreBindings dflags 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 :: String -> Bool -> [CoreBinding] -> IO ()
+lintCoreBindings :: DynFlags -> String -> [CoreBind] -> IO ()
-lintCoreBindings whoDunnit spec_done binds
- | not opt_DoCoreLinting
+lintCoreBindings dflags whoDunnit binds
+ | not (dopt Opt_DoCoreLinting dflags)
= return ()
-lintCoreBindings whoDunnit spec_done binds
- = case (initL (lint_binds binds) spec_done) of
- Nothing -> doIfSet opt_D_show_passes
- (hPutStr stderr ("*** Core Linted result of " ++ whoDunnit ++ "\n"))
-
+lintCoreBindings dflags whoDunnit binds
+ = case (initL (lint_binds binds)) of
+ Nothing -> showPass dflags ("Core Linted result of " ++ whoDunnit)
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)
+ -- Put all the top-level binders in scope at the start
+ -- This is because transformation rules can bring something
+ -- into use 'unexpectedly'
+ lint_binds binds = addInScopeVars (bindersOfBinds binds) $
+ mapL lint_bind binds
+
+ lint_bind (Rec prs) = mapL (lintSingleBinding Recursive) prs `seqL`
+ returnL ()
+ lint_bind (NonRec bndr rhs) = lintSingleBinding NonRecursive (bndr,rhs)
display bad_news
- = vcat [
- text ("*** Core Lint Errors: in result of " ++ whoDunnit ++ " ***"),
+ = vcat [ text ("*** Core Lint Errors: in result of " ++ whoDunnit ++ " ***"),
bad_news,
ptext SLIT("*** Offending Program ***"),
pprCoreBindings binds,
(it is very painful to catch errors otherwise):
\begin{code}
-lintUnfolding :: SrcLoc -> CoreExpr -> Maybe CoreExpr
-
-lintUnfolding locn expr
- = case
- (initL (addLoc (ImportedUnfolding locn) (lintCoreExpr expr))
- True{-pretend spec done-})
- of
- Nothing -> Just expr
- Just msg ->
- pprTrace "WARNING: Discarded bad unfolding from interface:\n"
- (vcat [msg,
- ptext SLIT("*** Bad unfolding ***"),
- ppr expr,
- ptext SLIT("*** End unfolding ***")])
- Nothing
+lintUnfolding :: SrcLoc
+ -> [Var] -- Treat these as in scope
+ -> CoreExpr
+ -> Maybe Message -- Nothing => OK
+
+lintUnfolding locn vars expr
+ = initL (addLoc (ImportedUnfolding locn) $
+ addInScopeVars vars $
+ lintCoreExpr expr)
\end{code}
%************************************************************************
Check a core binding, returning the list of variables bound.
\begin{code}
-lintCoreBinding :: CoreBinding -> LintM [Id]
+lintSingleBinding rec_flag (binder,rhs)
+ = addLoc (RhsOf binder) $
-lintCoreBinding (NonRec binder rhs)
- = lintSingleBinding (binder,rhs) `seqL` returnL [binder]
-
-lintCoreBinding (Rec pairs)
- = addInScopeVars binders (
- mapL lintSingleBinding pairs `seqL` returnL binders
- )
- where
- binders = [b | (b,_) <- pairs]
-
-lintSingleBinding (binder,rhs)
- = 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 isUnpointedType)
- checkIfSpecDoneL (not (isUnpointedType (idType binder)))
- (mkRhsPrimMsg binder rhs) `seqL`
+ -- Check (not isUnLiftedType) (also checks for bogus unboxed tuples)
+ checkL (not (isUnLiftedType binder_ty)
+ || (isNonRec rec_flag && exprOkForSpeculation rhs))
+ (mkRhsPrimMsg binder rhs) `seqL`
-- Check whether binder's specialisations contain any out-of-scope variables
- ifSpecDoneL (mapL (checkSpecIdInScope binder) spec_vars `seqL` returnL ())
+ 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
- spec_vars = idSpecVars binder
-
+ 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)
- | 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 :: CoreExpr -> LintM Type
-lintCoreExpr (Lit lit) = returnL (Just (literalType lit))
+lintCoreExpr (Var var) = checkIdInScope var `seqL` returnL (idType var)
+lintCoreExpr (Lit lit) = returnL (literalType lit)
lintCoreExpr (Note (Coerce to_ty from_ty) expr)
- = lintCoreExpr expr `thenMaybeL` \ expr_ty ->
+ = 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 (Just to_ty)
+ returnL to_ty
lintCoreExpr (Note other_note expr)
= lintCoreExpr expr
-lintCoreExpr (Let binds body)
- = lintCoreBinding binds `thenL` \binders ->
- if (null binders) then
- lintCoreExpr body -- Can't add a new source location
- else
- addLoc (BodyOfLetRec binders)
- (addInScopeVars binders (lintCoreExpr body))
+lintCoreExpr (Let (NonRec bndr rhs) body)
+ = lintSingleBinding NonRecursive (bndr,rhs) `seqL`
+ addLoc (BodyOfLetRec [bndr])
+ (addInScopeVars [bndr] (lintCoreExpr body))
-lintCoreExpr e@(Con con args)
- = checkL (isDataCon con) (mkConErrMsg e) `seqL`
- lintCoreArgs {-False-} e (dataConRepType 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'
+lintCoreExpr (Let (Rec pairs) body)
+ = addInScopeVars bndrs $
+ mapL (lintSingleBinding Recursive) pairs `seqL`
+ addLoc (BodyOfLetRec bndrs) (lintCoreExpr body)
+ where
+ bndrs = map fst pairs
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 vb@(ValBinder var) expr)
- = addLoc (LambdaBodyOf vb)
- (addInScopeVars [var]
- (lintCoreExpr expr `thenMaybeL` \ty ->
- returnL (Just (mkFunTy (idType var) ty))))
-
-lintCoreExpr (Lam tb@(TyBinder tyvar) expr)
- = addLoc (LambdaBodyOf tb) $
- addInScopeTyVars [tyvar] $
- lintCoreExpr expr `thenMaybeL` \ ty ->
- returnL (Just(mkForAllTy tyvar ty))
-
-lintCoreExpr e@(Case scrut alts)
- = lintCoreExpr scrut `thenMaybeL` \ty ->
- lintCoreAlts alts ty
+ = lintCoreExpr fun `thenL` \ ty ->
+ addLoc (AnExpr e) $
+ lintCoreArg ty arg
+
+lintCoreExpr (Lam var expr)
+ = addLoc (LambdaBodyOf var) $
+ (if isId var then
+ checkL (not (isUnboxedTupleType (idType var))) (mkUnboxedTupleMsg var)
+ else
+ returnL ())
+ `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
+ checkCaseAlts 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)
+
+lintCoreExpr e@(Type ty)
+ = addErrL (mkStrangeTyMsg e)
\end{code}
%************************************************************************
%* *
%************************************************************************
-The boolean argument indicates whether we should flag type
-applications to primitive types as being errors.
+The basic version of these functions checks that the argument is a
+subtype of the required type, as one would expect.
\begin{code}
-lintCoreArgs :: {-Bool ->-} CoreExpr -> Type -> [CoreArg] -> LintM (Maybe Type)
+lintCoreArgs :: Type -> [CoreArg] -> LintM Type
+lintCoreArgs = lintCoreArgs0 checkTys
-lintCoreArgs _ ty [] = returnL (Just ty)
-lintCoreArgs e ty (a : args)
- = lintCoreArg e ty a `thenMaybeL` \ res ->
- lintCoreArgs e res args
+lintCoreArg :: Type -> CoreArg -> LintM Type
+lintCoreArg = lintCoreArg0 checkTys
\end{code}
-%************************************************************************
-%* *
-\subsection[lintCoreArg]{lintCoreArg}
-%* *
-%************************************************************************
+The primitive version of these functions takes a check argument,
+allowing a different comparison.
\begin{code}
-lintCoreArg :: {-Bool ->-} CoreExpr -> Type -> CoreArg -> LintM (Maybe Type)
+lintCoreArgs0 check_tys ty [] = returnL ty
+lintCoreArgs0 check_tys ty (a : args)
+ = lintCoreArg0 check_tys ty a `thenL` \ res ->
+ lintCoreArgs0 check_tys res args
-lintCoreArg e ty (LitArg lit)
- = -- Make sure function type matches argument
- 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
+lintCoreArg0 check_tys ty a@(Type arg_ty)
+ = lintTy arg_ty `seqL`
+ lintTyApp ty arg_ty
-lintCoreArg e ty (VarArg v)
- = -- Make sure variable is bound
- checkIdInScope v `seqL`
- -- Make sure function type matches argument
- 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
+lintCoreArg0 check_tys fun_ty arg
+ = -- Make sure function type matches argument
+ lintCoreExpr arg `thenL` \ arg_ty ->
+ let
+ err = mkAppMsg fun_ty arg_ty
+ in
+ case splitFunTy_maybe fun_ty of
+ Just (arg,res) -> check_tys arg arg_ty err `seqL`
+ returnL res
+ _ -> addErrL err
+\end{code}
-lintCoreArg e ty a@(TyArg arg_ty)
- = lintTy arg_ty `seqL`
- checkTyVarsInScope (tyVarsOfType arg_ty) `seqL`
- case (splitForAllTy_maybe ty) of
- Nothing -> addErrL (mkTyAppMsg SLIT("Illegal") ty arg_ty e) `seqL` returnL Nothing
+\begin{code}
+lintTyApp ty arg_ty
+ = case splitForAllTy_maybe ty of
+ Nothing -> addErrL (mkTyAppMsg ty arg_ty)
Just (tyvar,body) ->
+ if not (isTyVar tyvar) then addErrL (mkTyAppMsg ty arg_ty) else
let
tyvar_kind = tyVarKind tyvar
argty_kind = typeKind arg_ty
-- error :: forall a:*. String -> a
-- and then apply it to both boxed and unboxed types.
then
- returnL(Just(instantiateTy (mkTyVarEnv [(tyvar,arg_ty)]) body))
+ returnL (substTyWith [tyvar] [arg_ty] body)
else
- pprTrace "lintCoreArg:kinds:" (hsep [ppr tyvar_kind, ppr argty_kind]) $
- addErrL (mkKindErrMsg tyvar arg_ty e) `seqL` returnL Nothing
+ 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[lintCoreAlts]{lintCoreAlts}
%************************************************************************
\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 (con,args,rhs)
- = (case splitAlgTyConApp_maybe scrut_ty of
- Just (tycon, tys_applied, cons) | isDataTyCon tycon ->
- let
- arg_tys = dataConArgTys 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 (zipEqual "lintAlgAlt" arg_tys args) `seqL`
- returnL ()
-
- other -> addErrL (mkAlgAltMsg1 scrut_ty)
- ) `seqL`
- addInScopeVars args (
- lintCoreExpr rhs
- )
+checkCaseAlts :: CoreExpr -> Type -> [CoreAlt] -> LintM ()
+-- a) Check that the alts are non-empty
+-- b) Check that the DEFAULT comes first, if it exists
+-- c) Check that there's a default for infinite types
+-- NB: Algebraic cases are not necessarily exhaustive, because
+-- the simplifer correctly eliminates case that can't
+-- possibly match.
+
+checkCaseAlts e ty []
+ = addErrL (mkNullAltsMsg e)
+
+checkCaseAlts e ty alts
+ = checkL (all non_deflt con_alts) (mkNonDefltMsg e) `seqL`
+ checkL (isJust maybe_deflt || not is_infinite_ty)
+ (nonExhaustiveAltsMsg e)
+ where
+ (con_alts, maybe_deflt) = findDefault alts
+
+ non_deflt (DEFAULT, _, _) = False
+ non_deflt alt = True
+
+ is_infinite_ty = case splitTyConApp_maybe ty of
+ Nothing -> False
+ Just (tycon, tycon_arg_tys) -> isPrimTyCon tycon
+\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@(LitAlt lit, args, rhs)
+ = checkL (null args) (mkDefaultArgsMsg args) `seqL`
+ checkTys lit_ty scrut_ty
+ (mkBadPatMsg lit_ty scrut_ty) `seqL`
+ lintCoreExpr rhs
+ where
+ lit_ty = literalType lit
+
+lintCoreAlt scrut_ty alt@(DataAlt con, args, rhs)
+ = addLoc (CaseAlt alt) (
+
+ 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.
+ -- NB: relies on existential type args coming *after* ordinary type args
+ case splitTyConApp scrut_ty of { (tycon, tycon_arg_tys) ->
+ lintTyApps (dataConRepType 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
- 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)
+ mk_arg b | isTyVar b = Type (mkTyVarTy b)
+ | isId b = Var b
+ | otherwise = pprPanic "lintCoreAlt:mk_arg " (ppr b)
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
+lintBinder :: Var -> LintM ()
+lintBinder v = nopL
+-- ToDo: lint its type
+-- ToDo: lint its rules
+
lintTy :: Type -> LintM ()
-lintTy ty = returnL ()
--- ToDo: Check that ty is well-kinded and has no unbound tyvars
+lintTy ty = mapL checkIdInScope (varSetElems (tyVarsOfType ty)) `seqL`
+ returnL ()
+ -- ToDo: check the kind structure of the type
\end{code}
%************************************************************************
\begin{code}
-type LintM a = Bool -- True <=> specialisation has been done
- -> [LintLocInfo] -- Locations
+type LintM a = [LintLocInfo] -- Locations
-> IdSet -- Local vars in scope
- -> TyVarSet -- Local tyvars in scope
- -> Bag ErrMsg -- Error messages so far
- -> (a, Bag ErrMsg) -- Result and error messages (if any)
+ -> Bag Message -- Error messages so far
+ -> (Maybe a, Bag Message) -- Result and error messages (if any)
data LintLocInfo
- = RhsOf Id -- The variable bound
- | LambdaBodyOf CoreBinder -- The lambda-binder
- | BodyOfLetRec [Id] -- One of the binders
- | ImportedUnfolding SrcLoc -- Some imported unfolding (ToDo: say which)
-
-instance Outputable LintLocInfo where
- ppr (RhsOf v)
- = ppr (getSrcLoc v) <> colon <+>
- brackets (ptext SLIT("RHS of") <+> pp_binders [v])
-
- ppr (LambdaBodyOf (ValBinder b))
- = ppr (getSrcLoc b) <> colon <+>
- brackets (ptext SLIT("in body of lambda with binder") <+> pp_binder b)
-
- ppr (LambdaBodyOf (TyBinder b))
- = ppr (getSrcLoc b) <> colon <+>
- brackets (ptext SLIT("in body of lambda with type binder") <+> ppr b)
-
- ppr (BodyOfLetRec bs)
- = ppr (getSrcLoc (head bs)) <> colon <+>
- brackets (ptext SLIT("in body of letrec with binders") <+> pp_binders bs)
-
- ppr (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)]
+ = 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)
\end{code}
\begin{code}
-initL :: LintM a -> Bool -> Maybe ErrMsg
-initL m spec_done
- = case (m spec_done [] emptyIdSet emptyTyVarSet emptyBag) of { (_, errs) ->
- if isEmptyBag errs then
- Nothing
- else
- Just (vcat (bagToList errs))
- }
+initL :: LintM a -> Maybe Message {- errors -}
+initL m
+ = case m [] emptyVarSet emptyBag of
+ (_, errs) | isEmptyBag errs -> Nothing
+ | otherwise -> Just (vcat (punctuate (text "") (bagToList errs)))
returnL :: a -> LintM a
-returnL r spec loc scope tyscope 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 tyscope errs
- = case m spec loc scope tyscope errs of
- (r, errs') -> k r spec loc scope tyscope 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 tyscope errs
- = case m spec loc scope tyscope errs of
- (_, errs') -> k spec loc scope tyscope errs'
-
-thenMaybeL :: LintM (Maybe a) -> (a -> LintM (Maybe b)) -> LintM (Maybe b)
-thenMaybeL m k spec loc scope tyscope errs
- = case m spec loc scope tyscope errs of
- (Nothing, errs2) -> (Nothing, errs2)
- (Just r, errs2) -> k r spec loc scope tyscope 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 tyscope errs = ((), errs)
-checkL False msg spec loc scope tyscope errs = ((), addErr errs msg loc)
-
-checkIfSpecDoneL :: Bool -> ErrMsg -> LintM ()
-checkIfSpecDoneL True msg spec loc scope tyscope errs = ((), errs)
-checkIfSpecDoneL False msg True loc scope tyscope errs = ((), addErr errs msg loc)
-checkIfSpecDoneL False msg False loc scope tyscope errs = ((), errs)
-
-ifSpecDoneL :: LintM () -> LintM ()
-ifSpecDoneL m False loc scope tyscope errs = ((), errs)
-ifSpecDoneL m True loc scope tyscope errs = m True loc scope tyscope errs
-
-addErrL :: ErrMsg -> LintM ()
-addErrL msg spec loc scope tyscope errs = ((), addErr errs msg loc)
+checkL :: Bool -> Message -> LintM ()
+checkL True msg = nopL
+checkL False msg = addErrL msg
-addErr :: Bag ErrMsg -> ErrMsg -> [LintLocInfo] -> Bag ErrMsg
+addErrL :: Message -> LintM a
+addErrL msg loc scope errs = (Nothing, addErr errs msg loc)
+addErr :: Bag Message -> Message -> [LintLocInfo] -> Bag Message
addErr errs_so_far msg locs
- = ASSERT (not (null locs))
- errs_so_far `snocBag` (hang (ppr (head locs)) 4 msg)
+ = ASSERT( notNull locs )
+ errs_so_far `snocBag` mk_msg msg
+ where
+ (loc, cxt1) = dumpLoc (head locs)
+ cxts = [snd (dumpLoc loc) | loc <- locs]
+ context | opt_PprStyle_Debug = vcat (reverse cxts) $$ cxt1
+ | otherwise = cxt1
+
+ mk_msg msg = addErrLocHdrLine loc context msg
addLoc :: LintLocInfo -> LintM a -> LintM a
-addLoc extra_loc m spec loc scope tyscope errs
- = m spec (extra_loc:loc) scope tyscope errs
-
-addInScopeVars :: [Id] -> LintM a -> LintM a
-addInScopeVars ids m spec loc scope tyscope 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 = mkIdSet ids
+addLoc extra_loc m loc scope errs
+ = m (extra_loc:loc) scope errs
--- 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 (uniqSetToList shadowed))) (
- m spec loc (scope `unionIdSets` new_set) tyscope errs
--- )
-
-addInScopeTyVars :: [TyVar] -> LintM a -> LintM a
-addInScopeTyVars tyvars m spec loc scope tyscope errs
- = m spec loc scope (tyscope `unionTyVarSets` new_set) errs
- where
- new_set = mkTyVarSet tyvars
-
+addInScopeVars :: [Var] -> LintM a -> LintM a
+addInScopeVars ids m loc scope errs
+ = m loc (scope `unionVarSet` mkVarSet ids) errs
\end{code}
\begin{code}
-checkIdInScope :: Id -> LintM ()
+checkIdInScope :: Var -> LintM ()
checkIdInScope id
= checkInScope (ptext SLIT("is out of scope")) id
-checkSpecIdInScope :: Id -> Id -> LintM ()
-checkSpecIdInScope binder id
+checkBndrIdInScope :: Var -> Var -> LintM ()
+checkBndrIdInScope binder id
= checkInScope msg id
where
- msg = ptext SLIT("is out of scope inside specialisation info for") <+>
+ msg = ptext SLIT("is out of scope inside info for") <+>
ppr binder
-checkInScope :: SDoc -> Id -> LintM ()
-checkInScope loc_msg id spec loc scope tyscope 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)
-
-checkTyVarsInScope :: TyVarSet -> LintM ()
-checkTyVarsInScope tyvars spec loc scope tyscope errs
--- | not (isEmptyTyVarSet out_of_scope) = ((), errs')
- | otherwise = ((), errs)
- where
- out_of_scope = tyvars `minusTyVarSet` tyscope
- errs' =
- foldr (\ tv errs -> addErr errs (hsep [ppr tv, ptext SLIT("is out of scope")]) loc)
- errs
- (tyVarSetToList out_of_scope)
-
-checkTys :: Type -> Type -> ErrMsg -> LintM ()
-checkTys ty1 ty2 msg spec loc scope tyscope errs
- = if ty1 == ty2 then ((), errs) else ((), addErr errs msg loc)
+checkInScope :: SDoc -> Var -> LintM ()
+checkInScope loc_msg var loc scope errs
+ | mustHaveLocalBinding var && not (var `elemVarSet` scope)
+ = (Nothing, addErr errs (hsep [ppr var, loc_msg]) loc)
+ | otherwise
+ = nopL loc scope errs
+
+checkTys :: Type -> Type -> Message -> LintM ()
+-- check ty2 is subtype of ty1 (ie, has same structure but usage
+-- annotations need only be consistent, not equal)
+checkTys ty1 ty2 msg
+ | ty1 `eqType` ty2 = nopL
+ | otherwise = addErrL msg
\end{code}
+
+%************************************************************************
+%* *
+\subsection{Error messages}
+%* *
+%************************************************************************
+
\begin{code}
-mkConErrMsg e
- = ($$) (ptext SLIT("Application of newtype constructor:"))
- (ppr e)
+dumpLoc (RhsOf v)
+ = (getSrcLoc v, brackets (ptext SLIT("RHS of") <+> pp_binders [v]))
+dumpLoc (LambdaBodyOf b)
+ = (getSrcLoc b, brackets (ptext SLIT("in body of lambda with binder") <+> pp_binder b))
-mkCaseAltMsg :: CoreCaseAlts -> ErrMsg
-mkCaseAltMsg alts
- = ($$) (ptext SLIT("Type of case alternatives not the same:"))
- (ppr alts)
+dumpLoc (BodyOfLetRec [])
+ = (noSrcLoc, brackets (ptext SLIT("In body of a letrec with no binders")))
-mkCaseAbstractMsg :: TyCon -> ErrMsg
-mkCaseAbstractMsg tycon
- = ($$) (ptext SLIT("An algebraic case on some weird type:"))
- (ppr tycon)
+dumpLoc (BodyOfLetRec bs@(_:_))
+ = ( getSrcLoc (head bs), brackets (ptext SLIT("in body of letrec with binders") <+> pp_binders bs))
-mkDefltMsg :: CoreCaseDefault -> ErrMsg
-mkDefltMsg deflt
- = ($$) (ptext SLIT("Binder in case default doesn't match type of scrutinee:"))
- (ppr deflt)
+dumpLoc (AnExpr e)
+ = (noSrcLoc, text "In the expression:" <+> ppr e)
-mkAppMsg :: Type -> Type -> CoreExpr -> ErrMsg
-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)]
+dumpLoc (CaseAlt (con, args, rhs))
+ = (noSrcLoc, text "In a case pattern:" <+> parens (ppr con <+> ppr args))
-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)]
+dumpLoc (ImportedUnfolding locn)
+ = (locn, brackets (ptext SLIT("in an imported unfolding")))
-mkTyAppMsg :: FAST_STRING -> Type -> Type -> CoreExpr -> ErrMsg
-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)]
+pp_binders :: [Var] -> SDoc
+pp_binders bs = sep (punctuate comma (map pp_binder bs))
-mkAlgAltMsg1 :: Type -> ErrMsg
-mkAlgAltMsg1 ty
- = ($$) (text "In some case statement, type of scrutinee is not a data type:")
- (ppr ty)
+pp_binder :: Var -> SDoc
+pp_binder b | isId b = hsep [ppr b, dcolon, ppr (idType b)]
+ | isTyVar b = hsep [ppr b, dcolon, ppr (tyVarKind b)]
+\end{code}
-mkAlgAltMsg2 :: Type -> Id -> ErrMsg
-mkAlgAltMsg2 ty con
- = vcat [
- text "In some algebraic case alternative, constructor is not a constructor of scrutinee type:",
- ppr ty,
- ppr con
- ]
+\begin{code}
+------------------------------------------------------
+-- Messages for case expressions
+
+mkNullAltsMsg :: CoreExpr -> Message
+mkNullAltsMsg e
+ = hang (text "Case expression with no alternatives:")
+ 4 (ppr e)
+
+mkDefaultArgsMsg :: [Var] -> Message
+mkDefaultArgsMsg args
+ = hang (text "DEFAULT case with binders")
+ 4 (ppr args)
+
+mkCaseAltMsg :: CoreExpr -> Message
+mkCaseAltMsg e
+ = hang (text "Type of case alternatives not the same:")
+ 4 (ppr e)
+
+mkScrutMsg :: Id -> Type -> Message
+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]
-mkAlgAltMsg3 :: Id -> [Id] -> ErrMsg
-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
+mkNonDefltMsg e
+ = hang (text "Case expression with DEFAULT not at the beginnning") 4 (ppr e)
+
+nonExhaustiveAltsMsg :: CoreExpr -> Message
+nonExhaustiveAltsMsg e
+ = hang (text "Case expression with non-exhaustive alternatives") 4 (ppr e)
+
+mkBadPatMsg :: Type -> Type -> Message
+mkBadPatMsg con_result_ty scrut_ty
= vcat [
- text "In some algebraic case alternative, type of argument doesn't match data constructor:",
- ppr ty,
- ppr arg
+ 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
- = ($$)
- (text "In a primitive case alternative, type of literal doesn't match type of scrutinee:")
- (ppr alt)
+------------------------------------------------------
+-- Other error messages
+
+mkAppMsg :: Type -> Type -> Message
+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 -> Message
+mkKindErrMsg tyvar arg_ty
+ = vcat [ptext SLIT("Kinds don't match in type application:"),
+ hang (ptext SLIT("Type variable:"))
+ 4 (ppr tyvar <+> dcolon <+> ppr (tyVarKind tyvar)),
+ hang (ptext SLIT("Arg type:"))
+ 4 (ppr arg_ty <+> dcolon <+> ppr (typeKind arg_ty))]
+
+mkTyAppMsg :: Type -> Type -> Message
+mkTyAppMsg ty arg_ty
+ = vcat [text "Illegal type application:",
+ hang (ptext SLIT("Exp type:"))
+ 4 (ppr ty <+> dcolon <+> ppr (typeKind ty)),
+ hang (ptext SLIT("Arg type:"))
+ 4 (ppr arg_ty <+> dcolon <+> ppr (typeKind arg_ty))]
-mkRhsMsg :: Id -> Type -> ErrMsg
+mkRhsMsg :: Id -> Type -> Message
mkRhsMsg binder ty
= vcat
[hsep [ptext SLIT("The type of this binder doesn't match the type of its RHS:"),
hsep [ptext SLIT("Binder's type:"), ppr (idType binder)],
hsep [ptext SLIT("Rhs type:"), ppr ty]]
-mkRhsPrimMsg :: Id -> CoreExpr -> ErrMsg
+mkRhsPrimMsg :: Id -> CoreExpr -> Message
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)]
]
+mkUnboxedTupleMsg :: Id -> Message
+mkUnboxedTupleMsg binder
+ = vcat [hsep [ptext SLIT("A variable has unboxed tuple type:"), ppr binder],
+ hsep [ptext SLIT("Binder's type:"), ppr (idType binder)]]
+
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
]
+
+mkStrangeTyMsg e
+ = ptext SLIT("Type where expression expected:") <+> ppr e
\end{code}
projects / ghc-hetmet.git / blobdiff