X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FcoreSyn%2FCoreLint.lhs;h=ffccf6f45c8344b1ea0431195a64740c19cf28eb;hb=55a95e74e844fee27a9990beb9350b033a4e1344;hp=345fb733c7dfaefcc3054d4f349fbe5077af3c6a;hpb=30c122df62ec75f9ed7f392f24c2925675bf1d06;p=ghc-hetmet.git
diff --git a/compiler/coreSyn/CoreLint.lhs b/compiler/coreSyn/CoreLint.lhs
index 345fb73..ffccf6f 100644
--- a/compiler/coreSyn/CoreLint.lhs
+++ b/compiler/coreSyn/CoreLint.lhs
@@ -28,6 +28,7 @@ import VarEnv
import VarSet
import Name
import Id
+import IdInfo
import PprCore
import ErrUtils
import SrcLoc
@@ -114,21 +115,15 @@ Outstanding issues:
-- may well be happening...);
-Note [Type lets]
-~~~~~~~~~~~~~~~~
+Note [Linting type lets]
+~~~~~~~~~~~~~~~~~~~~~~~~
In the desugarer, it's very very convenient to be able to say (in effect)
- let a = Int in
-That is, use a type let. (See notes just below for why we want this.)
-
-We don't have type lets in Core, so the desugarer uses type lambda
- (/\a. ) Int
-However, in the lambda form, we'd get lint errors from:
- (/\a. let x::a = 4 in ) Int
-because (x::a) doesn't look compatible with (4::Int).
-
-So (HACK ALERT) the Lint phase does type-beta reduction "on the fly",
-as it were. It carries a type substitution (in this example [a -> Int])
-and applies this substitution before comparing types. The functin
+ let a = Type Int in
+That is, use a type let. See Note [Type let] in CoreSyn.
+
+However, when linting we need to remember that a=Int, else we might
+reject a correct program. So we carry a type substitution (in this example
+[a -> Int]) and apply this substitution before comparing types. The functin
lintTy :: Type -> LintM Type
returns a substituted type; that's the only reason it returns anything.
@@ -140,33 +135,6 @@ itself is part of the TvSubst we are carrying down), and when we
find an occurence of an Id, we fetch it from the in-scope set.
-Why we need type let
-~~~~~~~~~~~~~~~~~~~~
-It's needed when dealing with desugarer output for GADTs. Consider
- data T = forall a. T a (a->Int) Bool
- f :: T -> ... ->
- f (T x f True) =
- f (T y g False) =
-After desugaring we get
- f t b = case t of
- T a (x::a) (f::a->Int) (b:Bool) ->
- case b of
- True ->
- False -> (/\b. let y=x; g=f in ) a
-And for a reason I now forget, the ...... can mention a; so
-we want Lint to know that b=a. Ugh.
-
-I tried quite hard to make the necessity for this go away, by changing the
-desugarer, but the fundamental problem is this:
-
- T a (x::a) (y::Int) -> let fail::a = ...
- in (/\b. ...(case ... of
- True -> x::b
- False -> fail)
- ) a
-Now the inner case look as though it has incompatible branches.
-
-
\begin{code}
lintCoreBindings :: DynFlags -> String -> [CoreBind] -> IO ()
@@ -193,9 +161,9 @@ lintCoreBindings dflags whoDunnit binds
display bad_news
= vcat [ text ("*** Core Lint Errors: in result of " ++ whoDunnit ++ " ***"),
bad_news,
- ptext SLIT("*** Offending Program ***"),
+ ptext (sLit "*** Offending Program ***"),
pprCoreBindings binds,
- ptext SLIT("*** End of Offense ***")
+ ptext (sLit "*** End of Offense ***")
]
\end{code}
@@ -260,7 +228,10 @@ lintSingleBinding top_lvl_flag rec_flag (binder,rhs)
where
binder_ty = idType binder
maybeDmdTy = idNewStrictness_maybe binder
- bndr_vars = varSetElems (idFreeVars binder)
+ bndr_vars = varSetElems (idFreeVars binder `unionVarSet` wkr_vars)
+ wkr_vars | workerExists wkr_info = unitVarSet (workerId wkr_info)
+ | otherwise = emptyVarSet
+ wkr_info = idWorkerInfo binder
lintBinder var | isId var = lintIdBndr var $ \_ -> (return ())
| otherwise = return ()
\end{code}
@@ -279,10 +250,12 @@ lintCoreExpr :: CoreExpr -> LintM OutType
-- The returned type has the substitution from the monad
-- already applied to it:
-- lintCoreExpr e subst = exprType (subst e)
+--
+-- The returned "type" can be a kind, if the expression is (Type ty)
lintCoreExpr (Var var)
= do { checkL (not (var == oneTupleDataConId))
- (ptext SLIT("Illegal one-tuple"))
+ (ptext (sLit "Illegal one-tuple"))
; var' <- lookupIdInScope var
; return (idType var')
}
@@ -307,6 +280,20 @@ lintCoreExpr (Cast expr co)
lintCoreExpr (Note _ expr)
= lintCoreExpr expr
+lintCoreExpr (Let (NonRec tv (Type ty)) body)
+ = -- See Note [Type let] in CoreSyn
+ do { checkL (isTyVar tv) (mkKindErrMsg tv ty) -- Not quite accurate
+ ; ty' <- lintTy ty
+ ; kind' <- lintTy (tyVarKind tv)
+ ; let tv' = setTyVarKind tv kind'
+ ; checkKinds tv' ty'
+ -- Now extend the substitution so we
+ -- take advantage of it in the body
+ ; addLoc (BodyOfLetRec [tv]) $
+ addInScopeVars [tv'] $
+ extendSubstL tv' ty' $
+ lintCoreExpr body }
+
lintCoreExpr (Let (NonRec bndr rhs) body)
= do { lintSingleBinding NotTopLevel NonRecursive (bndr,rhs)
; addLoc (BodyOfLetRec [bndr])
@@ -319,29 +306,6 @@ lintCoreExpr (Let (Rec pairs) body)
where
bndrs = map fst pairs
-lintCoreExpr e@(App fun (Type ty))
--- See Note [Type let] above
- = addLoc (AnExpr e) $
- go fun [ty]
- where
- go (App fun (Type ty)) tys
- = do { go fun (ty:tys) }
- go (Lam tv body) (ty:tys)
- = do { checkL (isTyVar tv) (mkKindErrMsg tv ty) -- Not quite accurate
- ; ty' <- lintTy ty
- ; let kind = tyVarKind tv
- ; kind' <- lintTy kind
- ; let tv' = setTyVarKind tv kind'
- ; checkKinds tv' ty'
- -- Now extend the substitution so we
- -- take advantage of it in the body
- ; addInScopeVars [tv'] $
- extendSubstL tv' ty' $
- go body tys }
- go fun tys
- = do { fun_ty <- lintCoreExpr fun
- ; lintCoreArgs fun_ty (map Type tys) }
-
lintCoreExpr e@(App fun arg)
= do { fun_ty <- lintCoreExpr fun
; addLoc (AnExpr e) $
@@ -363,6 +327,18 @@ lintCoreExpr e@(Case scrut var alt_ty alts) =
do { scrut_ty <- lintCoreExpr scrut
; alt_ty <- lintTy alt_ty
; var_ty <- lintTy (idType var)
+
+ ; let mb_tc_app = splitTyConApp_maybe (idType var)
+ ; case mb_tc_app of
+ Just (tycon, _)
+ | debugIsOn &&
+ isAlgTyCon tycon &&
+ null (tyConDataCons tycon) ->
+ pprTrace "Lint warning: case binder's type has no constructors" (ppr var <+> ppr (idType var))
+ -- This can legitimately happen for type families
+ $ return ()
+ _otherwise -> return ()
+
-- Don't use lintIdBndr on var, because unboxed tuple is legitimate
; subst <- getTvSubst
@@ -380,8 +356,9 @@ lintCoreExpr e@(Case scrut var alt_ty alts) =
where
pass_var f = f var
-lintCoreExpr e@(Type _)
- = addErrL (mkStrangeTyMsg e)
+lintCoreExpr (Type ty)
+ = do { ty' <- lintTy ty
+ ; return (typeKind ty') }
\end{code}
%************************************************************************
@@ -589,12 +566,13 @@ lintAndScopeIds ids linterF
lintAndScopeId :: Var -> (Var -> LintM a) -> LintM a
lintAndScopeId id linterF
= do { ty <- lintTy (idType id)
- ; let id' = Var.setIdType id ty
+ ; let id' = setIdType id ty
; addInScopeVars [id'] $ (linterF id')
}
lintTy :: InType -> LintM OutType
-- Check the type, and apply the substitution to it
+-- See Note [Linting type lets]
-- ToDo: check the kind structure of the type
lintTy ty
= do { ty' <- applySubst ty
@@ -648,7 +626,7 @@ data LintLocInfo
| LambdaBodyOf Id -- The lambda-binder
| BodyOfLetRec [Id] -- One of the binders
| CaseAlt CoreAlt -- Case alternative
- | CasePat CoreAlt -- *Pattern* of the case alternative
+ | CasePat CoreAlt -- The *pattern* of the case alternative
| AnExpr CoreExpr -- Some expression
| ImportedUnfolding SrcLoc -- Some imported unfolding (ToDo: say which)
| TopLevelBindings
@@ -679,7 +657,7 @@ addErr subst errs_so_far msg locs
(loc, cxt1) = dumpLoc (head locs)
cxts = [snd (dumpLoc loc) | loc <- locs]
context | opt_PprStyle_Debug = vcat (reverse cxts) $$ cxt1 $$
- ptext SLIT("Substitution:") <+> ppr subst
+ ptext (sLit "Substitution:") <+> ppr subst
| otherwise = cxt1
mk_msg msg = mkLocMessage (mkSrcSpan loc loc) (context $$ msg)
@@ -724,7 +702,7 @@ lookupIdInScope id
Nothing -> do { addErrL out_of_scope
; return id } }
where
- out_of_scope = ppr id <+> ptext SLIT("is out of scope")
+ out_of_scope = ppr id <+> ptext (sLit "is out of scope")
oneTupleDataConId :: Id -- Should not happen
@@ -734,11 +712,11 @@ checkBndrIdInScope :: Var -> Var -> LintM ()
checkBndrIdInScope binder id
= checkInScope msg id
where
- msg = ptext SLIT("is out of scope inside info for") <+>
+ msg = ptext (sLit "is out of scope inside info for") <+>
ppr binder
checkTyVarInScope :: TyVar -> LintM ()
-checkTyVarInScope tv = checkInScope (ptext SLIT("is out of scope")) tv
+checkTyVarInScope tv = checkInScope (ptext (sLit "is out of scope")) tv
checkInScope :: SDoc -> Var -> LintM ()
checkInScope loc_msg var =
@@ -763,16 +741,16 @@ checkTys ty1 ty2 msg = checkL (ty1 `coreEqType` ty2) msg
dumpLoc :: LintLocInfo -> (SrcLoc, SDoc)
dumpLoc (RhsOf v)
- = (getSrcLoc v, brackets (ptext SLIT("RHS of") <+> pp_binders [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))
+ = (getSrcLoc b, brackets (ptext (sLit "in body of lambda with binder") <+> pp_binder b))
dumpLoc (BodyOfLetRec [])
- = (noSrcLoc, brackets (ptext SLIT("In body of a letrec with no binders")))
+ = (noSrcLoc, brackets (ptext (sLit "In body of a letrec with no binders")))
dumpLoc (BodyOfLetRec bs@(_:_))
- = ( getSrcLoc (head bs), brackets (ptext SLIT("in body of letrec with binders") <+> pp_binders bs))
+ = ( getSrcLoc (head bs), brackets (ptext (sLit "in body of letrec with binders") <+> pp_binders bs))
dumpLoc (AnExpr e)
= (noSrcLoc, text "In the expression:" <+> ppr e)
@@ -784,7 +762,7 @@ dumpLoc (CasePat (con, args, _))
= (noSrcLoc, text "In the pattern of a case alternative:" <+> parens (ppr con <+> pp_binders args))
dumpLoc (ImportedUnfolding locn)
- = (locn, brackets (ptext SLIT("in an imported unfolding")))
+ = (locn, brackets (ptext (sLit "in an imported unfolding")))
dumpLoc TopLevelBindings
= (noSrcLoc, empty)
@@ -820,7 +798,7 @@ mkScrutMsg var var_ty scrut_ty subst
= vcat [text "Result binder in case doesn't match scrutinee:" <+> ppr var,
text "Result binder type:" <+> ppr var_ty,--(idType var),
text "Scrutinee type:" <+> ppr scrut_ty,
- hsep [ptext SLIT("Current TV subst"), ppr subst]]
+ hsep [ptext (sLit "Current TV subst"), ppr subst]]
mkNonDefltMsg, mkNonIncreasingAltsMsg :: CoreExpr -> Message
mkNonDefltMsg e
@@ -866,87 +844,83 @@ mkNewTyDataConAltMsg scrut_ty alt
mkAppMsg :: Type -> Type -> CoreExpr -> Message
mkAppMsg fun_ty arg_ty arg
- = vcat [ptext SLIT("Argument value doesn't match argument type:"),
- hang (ptext SLIT("Fun type:")) 4 (ppr fun_ty),
- hang (ptext SLIT("Arg type:")) 4 (ppr arg_ty),
- hang (ptext SLIT("Arg:")) 4 (ppr arg)]
+ = vcat [ptext (sLit "Argument value doesn't match argument type:"),
+ hang (ptext (sLit "Fun type:")) 4 (ppr fun_ty),
+ hang (ptext (sLit "Arg type:")) 4 (ppr arg_ty),
+ hang (ptext (sLit "Arg:")) 4 (ppr arg)]
mkNonFunAppMsg :: Type -> Type -> CoreExpr -> Message
mkNonFunAppMsg fun_ty arg_ty arg
- = vcat [ptext SLIT("Non-function type in function position"),
- hang (ptext SLIT("Fun type:")) 4 (ppr fun_ty),
- hang (ptext SLIT("Arg type:")) 4 (ppr arg_ty),
- hang (ptext SLIT("Arg:")) 4 (ppr arg)]
+ = vcat [ptext (sLit "Non-function type in function position"),
+ hang (ptext (sLit "Fun type:")) 4 (ppr fun_ty),
+ hang (ptext (sLit "Arg type:")) 4 (ppr arg_ty),
+ hang (ptext (sLit "Arg:")) 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:"))
+ = 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:"))
+ 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:"))
+ hang (ptext (sLit "Exp type:"))
4 (ppr ty <+> dcolon <+> ppr (typeKind ty)),
- hang (ptext SLIT("Arg type:"))
+ hang (ptext (sLit "Arg type:"))
4 (ppr arg_ty <+> dcolon <+> ppr (typeKind arg_ty))]
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 "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]]
+ hsep [ptext (sLit "Binder's type:"), ppr (idType binder)],
+ hsep [ptext (sLit "Rhs type:"), ppr ty]]
mkRhsPrimMsg :: Id -> CoreExpr -> Message
mkRhsPrimMsg binder _rhs
- = vcat [hsep [ptext SLIT("The type of this binder is primitive:"),
+ = vcat [hsep [ptext (sLit "The type of this binder is primitive:"),
ppr binder],
- hsep [ptext SLIT("Binder's type:"), ppr (idType binder)]
+ hsep [ptext (sLit "Binder's type:"), ppr (idType binder)]
]
mkStrictMsg :: Id -> Message
mkStrictMsg binder
- = vcat [hsep [ptext SLIT("Recursive or top-level binder has strict demand info:"),
+ = vcat [hsep [ptext (sLit "Recursive or top-level binder has strict demand info:"),
ppr binder],
- hsep [ptext SLIT("Binder's demand info:"), ppr (idNewDemandInfo binder)]
+ hsep [ptext (sLit "Binder's demand info:"), ppr (idNewDemandInfo binder)]
]
mkArityMsg :: Id -> Message
mkArityMsg binder
- = vcat [hsep [ptext SLIT("Demand type has "),
+ = vcat [hsep [ptext (sLit "Demand type has "),
ppr (dmdTypeDepth dmd_ty),
- ptext SLIT(" arguments, rhs has "),
+ ptext (sLit " arguments, rhs has "),
ppr (idArity binder),
- ptext SLIT("arguments, "),
+ ptext (sLit "arguments, "),
ppr binder],
- hsep [ptext SLIT("Binder's strictness signature:"), ppr dmd_ty]
+ hsep [ptext (sLit "Binder's strictness signature:"), ppr dmd_ty]
]
where (StrictSig dmd_ty) = idNewStrictness 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)]]
+ = vcat [hsep [ptext (sLit "A variable has unboxed tuple type:"), ppr binder],
+ hsep [ptext (sLit "Binder's type:"), ppr (idType binder)]]
mkCastErr :: Type -> Type -> Message
mkCastErr from_ty expr_ty
- = vcat [ptext SLIT("From-type of Cast differs from type of enclosed expression"),
- ptext SLIT("From-type:") <+> ppr from_ty,
- ptext SLIT("Type of enclosed expr:") <+> ppr expr_ty
+ = vcat [ptext (sLit "From-type of Cast differs from type of enclosed expression"),
+ ptext (sLit "From-type:") <+> ppr from_ty,
+ ptext (sLit "Type of enclosed expr:") <+> ppr expr_ty
]
dupVars :: [[Var]] -> Message
dupVars vars
- = hang (ptext SLIT("Duplicate variables brought into scope"))
+ = hang (ptext (sLit "Duplicate variables brought into scope"))
2 (ppr vars)
-
-mkStrangeTyMsg :: CoreExpr -> Message
-mkStrangeTyMsg e
- = ptext SLIT("Type where expression expected:") <+> ppr e
\end{code}