2 % (c) The University of Glasgow 2006
8 -- the "tc" prefix indicates that matching always
9 -- respects newtypes (rather than looking through them)
10 tcMatchTy, tcMatchTys, tcMatchTyX,
11 ruleMatchTyX, tcMatchPreds, MatchEnv(..),
15 -- Side-effect free unification
16 tcUnifyTys, BindFlag(..),
17 niFixTvSubst, niSubstTvSet
21 #include "HsVersions.h"
39 %************************************************************************
43 %************************************************************************
46 Matching is much tricker than you might think.
48 1. The substitution we generate binds the *template type variables*
49 which are given to us explicitly.
51 2. We want to match in the presence of foralls;
52 e.g (forall a. t1) ~ (forall b. t2)
54 That is what the RnEnv2 is for; it does the alpha-renaming
55 that makes it as if a and b were the same variable.
56 Initialising the RnEnv2, so that it can generate a fresh
57 binder when necessary, entails knowing the free variables of
60 3. We must be careful not to bind a template type variable to a
61 locally bound variable. E.g.
62 (forall a. x) ~ (forall b. b)
63 where x is the template type variable. Then we do not want to
64 bind x to a/b! This is a kind of occurs check.
65 The necessary locals accumulate in the RnEnv2.
70 = ME { me_tmpls :: VarSet -- Template tyvars
71 , me_env :: RnEnv2 -- Renaming envt for nested foralls
72 } -- In-scope set includes template tyvars
74 tcMatchTy :: TyVarSet -- Template tyvars
77 -> Maybe TvSubst -- One-shot; in principle the template
78 -- variables could be free in the target
80 tcMatchTy tmpls ty1 ty2
81 = case match menv emptyTvSubstEnv ty1 ty2 of
82 Just subst_env -> Just (TvSubst in_scope subst_env)
85 menv = ME { me_tmpls = tmpls, me_env = mkRnEnv2 in_scope }
86 in_scope = mkInScopeSet (tmpls `unionVarSet` tyVarsOfType ty2)
87 -- We're assuming that all the interesting
88 -- tyvars in tys1 are in tmpls
90 tcMatchTys :: TyVarSet -- Template tyvars
93 -> Maybe TvSubst -- One-shot; in principle the template
94 -- variables could be free in the target
96 tcMatchTys tmpls tys1 tys2
97 = case match_tys menv emptyTvSubstEnv tys1 tys2 of
98 Just subst_env -> Just (TvSubst in_scope subst_env)
101 menv = ME { me_tmpls = tmpls, me_env = mkRnEnv2 in_scope }
102 in_scope = mkInScopeSet (tmpls `unionVarSet` tyVarsOfTypes tys2)
103 -- We're assuming that all the interesting
104 -- tyvars in tys1 are in tmpls
106 -- This is similar, but extends a substitution
107 tcMatchTyX :: TyVarSet -- Template tyvars
108 -> TvSubst -- Substitution to extend
112 tcMatchTyX tmpls (TvSubst in_scope subst_env) ty1 ty2
113 = case match menv subst_env ty1 ty2 of
114 Just subst_env -> Just (TvSubst in_scope subst_env)
117 menv = ME {me_tmpls = tmpls, me_env = mkRnEnv2 in_scope}
120 :: [TyVar] -- Bind these
121 -> [PredType] -> [PredType]
123 tcMatchPreds tmpls ps1 ps2
124 = match_list (match_pred menv) emptyTvSubstEnv ps1 ps2
126 menv = ME { me_tmpls = mkVarSet tmpls, me_env = mkRnEnv2 in_scope_tyvars }
127 in_scope_tyvars = mkInScopeSet (tyVarsOfTheta ps1 `unionVarSet` tyVarsOfTheta ps2)
129 -- This one is called from the expression matcher, which already has a MatchEnv in hand
130 ruleMatchTyX :: MatchEnv
131 -> TvSubstEnv -- Substitution to extend
136 ruleMatchTyX menv subst ty1 ty2 = match menv subst ty1 ty2 -- Rename for export
139 Now the internals of matching
142 match :: MatchEnv -- For the most part this is pushed downwards
143 -> TvSubstEnv -- Substitution so far:
144 -- Domain is subset of template tyvars
145 -- Free vars of range is subset of
146 -- in-scope set of the RnEnv2
147 -> Type -> Type -- Template and target respectively
149 -- This matcher works on core types; that is, it ignores PredTypes
150 -- Watch out if newtypes become transparent agin!
151 -- this matcher must respect newtypes
153 match menv subst ty1 ty2 | Just ty1' <- coreView ty1 = match menv subst ty1' ty2
154 | Just ty2' <- coreView ty2 = match menv subst ty1 ty2'
156 match menv subst (TyVarTy tv1) ty2
157 | Just ty1' <- lookupVarEnv subst tv1' -- tv1' is already bound
158 = if tcEqTypeX (nukeRnEnvL rn_env) ty1' ty2
159 -- ty1 has no locally-bound variables, hence nukeRnEnvL
160 -- Note tcEqType...we are doing source-type matching here
162 else Nothing -- ty2 doesn't match
164 | tv1' `elemVarSet` me_tmpls menv
165 = if any (inRnEnvR rn_env) (varSetElems (tyVarsOfType ty2))
166 then Nothing -- Occurs check
167 else do { subst1 <- match_kind menv subst tv1 ty2
168 -- Note [Matching kinds]
169 ; return (extendVarEnv subst1 tv1' ty2) }
171 | otherwise -- tv1 is not a template tyvar
173 TyVarTy tv2 | tv1' == rnOccR rn_env tv2 -> Just subst
177 tv1' = rnOccL rn_env tv1
179 match menv subst (ForAllTy tv1 ty1) (ForAllTy tv2 ty2)
180 = match menv' subst ty1 ty2
181 where -- Use the magic of rnBndr2 to go under the binders
182 menv' = menv { me_env = rnBndr2 (me_env menv) tv1 tv2 }
184 match menv subst (PredTy p1) (PredTy p2)
185 = match_pred menv subst p1 p2
186 match menv subst (TyConApp tc1 tys1) (TyConApp tc2 tys2)
187 | tc1 == tc2 = match_tys menv subst tys1 tys2
188 match menv subst (FunTy ty1a ty1b) (FunTy ty2a ty2b)
189 = do { subst' <- match menv subst ty1a ty2a
190 ; match menv subst' ty1b ty2b }
191 match menv subst (AppTy ty1a ty1b) ty2
192 | Just (ty2a, ty2b) <- repSplitAppTy_maybe ty2
193 -- 'repSplit' used because the tcView stuff is done above
194 = do { subst' <- match menv subst ty1a ty2a
195 ; match menv subst' ty1b ty2b }
201 match_kind :: MatchEnv -> TvSubstEnv -> TyVar -> Type -> Maybe TvSubstEnv
202 -- Match the kind of the template tyvar with the kind of Type
203 -- Note [Matching kinds]
204 match_kind menv subst tv ty
205 | isCoVar tv = do { let (ty1,ty2) = coVarKind tv
206 (ty3,ty4) = coercionKind ty
207 ; subst1 <- match menv subst ty1 ty3
208 ; match menv subst1 ty2 ty4 }
209 | otherwise = if typeKind ty `isSubKind` tyVarKind tv
213 -- Note [Matching kinds]
214 -- ~~~~~~~~~~~~~~~~~~~~~
215 -- For ordinary type variables, we don't want (m a) to match (n b)
216 -- if say (a::*) and (b::*->*). This is just a yes/no issue.
218 -- For coercion kinds matters are more complicated. If we have a
219 -- coercion template variable co::a~[b], where a,b are presumably also
220 -- template type variables, then we must match co's kind against the
221 -- kind of the actual argument, so as to give bindings to a,b.
223 -- In fact I have no example in mind that *requires* this kind-matching
224 -- to instantiate template type variables, but it seems like the right
225 -- thing to do. C.f. Note [Matching variable types] in Rules.lhs
228 match_tys :: MatchEnv -> TvSubstEnv -> [Type] -> [Type] -> Maybe TvSubstEnv
229 match_tys menv subst tys1 tys2 = match_list (match menv) subst tys1 tys2
232 match_list :: (TvSubstEnv -> a -> a -> Maybe TvSubstEnv)
233 -> TvSubstEnv -> [a] -> [a] -> Maybe TvSubstEnv
234 match_list _ subst [] [] = Just subst
235 match_list fn subst (ty1:tys1) (ty2:tys2) = do { subst' <- fn subst ty1 ty2
236 ; match_list fn subst' tys1 tys2 }
237 match_list _ _ _ _ = Nothing
240 match_pred :: MatchEnv -> TvSubstEnv -> PredType -> PredType -> Maybe TvSubstEnv
241 match_pred menv subst (ClassP c1 tys1) (ClassP c2 tys2)
242 | c1 == c2 = match_tys menv subst tys1 tys2
243 match_pred menv subst (IParam n1 t1) (IParam n2 t2)
244 | n1 == n2 = match menv subst t1 t2
245 match_pred _ _ _ _ = Nothing
249 %************************************************************************
253 %************************************************************************
255 Note [Pruning dead case alternatives]
256 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
257 Consider data T a where
265 type instance F Bool = Int
267 Now consider case x of { T1 -> e1; T2 -> e2 }
269 The question before the house is this: if I know something about the type
270 of x, can I prune away the T1 alternative?
272 Suppose x::T Char. It's impossible to construct a (T Char) using T1,
273 Answer = YES (clearly)
275 Suppose x::T (F a), where 'a' is in scope. Then 'a' might be instantiated
276 to 'Bool', in which case x::T Int, so
277 ANSWER = NO (clearly)
279 Suppose x::T X. Then *in Haskell* it's impossible to construct a (non-bottom)
280 value of type (T X) using T1. But *in FC* it's quite possible. The newtype
283 So (T CoX) :: T X ~ T Int; hence (T1 `cast` sym (T CoX)) is a non-bottom value
284 of type (T X) constructed with T1. Hence
285 ANSWER = NO (surprisingly)
287 Furthermore, this can even happen; see Trac #1251. GHC's newtype-deriving
288 mechanism uses a cast, just as above, to move from one dictionary to another,
289 in effect giving the programmer access to CoX.
291 Finally, suppose x::T Y. Then *even in FC* we can't construct a
292 non-bottom value of type (T Y) using T1. That's because we can get
293 from Y to Char, but not to Int.
296 Here's a related question. data Eq a b where EQ :: Eq a a
298 case x of { EQ -> ... }
300 Suppose x::Eq Int Char. Is the alternative dead? Clearly yes.
302 What about x::Eq Int a, in a context where we have evidence that a~Char.
303 Then again the alternative is dead.
308 We are really doing a test for unsatisfiability of the type
309 constraints implied by the match. And that is clearly, in general, a
312 However, since we are simply dropping dead code, a conservative test
313 suffices. There is a continuum of tests, ranging from easy to hard, that
314 drop more and more dead code.
316 For now we implement a very simple test: type variables match
317 anything, type functions (incl newtypes) match anything, and only
318 distinct data types fail to match. We can elaborate later.
321 dataConCannotMatch :: [Type] -> DataCon -> Bool
322 -- Returns True iff the data con *definitely cannot* match a
323 -- scrutinee of type (T tys)
324 -- where T is the type constructor for the data con
326 dataConCannotMatch tys con
327 | null eq_spec = False -- Common
328 | all isTyVarTy tys = False -- Also common
330 = cant_match_s (map (substTyVar subst . fst) eq_spec)
333 dc_tvs = dataConUnivTyVars con
334 eq_spec = dataConEqSpec con
335 subst = zipTopTvSubst dc_tvs tys
337 cant_match_s :: [Type] -> [Type] -> Bool
338 cant_match_s tys1 tys2 = ASSERT( equalLength tys1 tys2 )
339 or (zipWith cant_match tys1 tys2)
341 cant_match :: Type -> Type -> Bool
343 | Just t1' <- coreView t1 = cant_match t1' t2
344 | Just t2' <- coreView t2 = cant_match t1 t2'
346 cant_match (FunTy a1 r1) (FunTy a2 r2)
347 = cant_match a1 a2 || cant_match r1 r2
349 cant_match (TyConApp tc1 tys1) (TyConApp tc2 tys2)
350 | isDataTyCon tc1 && isDataTyCon tc2
351 = tc1 /= tc2 || cant_match_s tys1 tys2
353 cant_match (FunTy {}) (TyConApp tc _) = isDataTyCon tc
354 cant_match (TyConApp tc _) (FunTy {}) = isDataTyCon tc
355 -- tc can't be FunTyCon by invariant
357 cant_match (AppTy f1 a1) ty2
358 | Just (f2, a2) <- repSplitAppTy_maybe ty2
359 = cant_match f1 f2 || cant_match a1 a2
360 cant_match ty1 (AppTy f2 a2)
361 | Just (f1, a1) <- repSplitAppTy_maybe ty1
362 = cant_match f1 f2 || cant_match a1 a2
364 cant_match _ _ = False -- Safe!
366 -- Things we could add;
368 -- look through newtypes
369 -- take account of tyvar bindings (EQ example above)
374 %************************************************************************
378 %************************************************************************
381 tcUnifyTys :: (TyVar -> BindFlag)
383 -> Maybe TvSubst -- A regular one-shot (idempotent) substitution
384 -- The two types may have common type variables, and indeed do so in the
385 -- second call to tcUnifyTys in FunDeps.checkClsFD
387 tcUnifyTys bind_fn tys1 tys2
388 = maybeErrToMaybe $ initUM bind_fn $
389 do { subst <- unifyList emptyTvSubstEnv tys1 tys2
391 -- Find the fixed point of the resulting non-idempotent substitution
392 ; return (niFixTvSubst subst) }
396 %************************************************************************
398 Non-idempotent substitution
400 %************************************************************************
402 Note [Non-idempotent substitution]
403 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
404 During unification we use a TvSubstEnv that is
406 (b) loop-free; ie repeatedly applying it yields a fixed point
409 niFixTvSubst :: TvSubstEnv -> TvSubst
410 -- Find the idempotent fixed point of the non-idempotent substitution
411 -- ToDo: use laziness instead of iteration?
412 niFixTvSubst env = f env
414 f e | not_fixpoint = f (mapVarEnv (substTy subst) e)
417 range_tvs = foldVarEnv (unionVarSet . tyVarsOfType) emptyVarSet e
418 subst = mkTvSubst (mkInScopeSet range_tvs) e
419 not_fixpoint = foldVarSet ((||) . in_domain) False range_tvs
420 in_domain tv = tv `elemVarEnv` e
422 niSubstTvSet :: TvSubstEnv -> TyVarSet -> TyVarSet
423 -- Apply the non-idempotent substitution to a set of type variables,
424 -- remembering that the substitution isn't necessarily idempotent
425 -- This is used in the occurs check, before extending the substitution
426 niSubstTvSet subst tvs
427 = foldVarSet (unionVarSet . get) emptyVarSet tvs
429 get tv = case lookupVarEnv subst tv of
430 Nothing -> unitVarSet tv
431 Just ty -> niSubstTvSet subst (tyVarsOfType ty)
434 %************************************************************************
438 %************************************************************************
441 unify :: TvSubstEnv -- An existing substitution to extend
442 -> Type -> Type -- Types to be unified, and witness of their equality
443 -> UM TvSubstEnv -- Just the extended substitution,
444 -- Nothing if unification failed
445 -- We do not require the incoming substitution to be idempotent,
446 -- nor guarantee that the outgoing one is. That's fixed up by
449 -- Respects newtypes, PredTypes
451 -- in unify, any NewTcApps/Preds should be taken at face value
452 unify subst (TyVarTy tv1) ty2 = uVar subst tv1 ty2
453 unify subst ty1 (TyVarTy tv2) = uVar subst tv2 ty1
455 unify subst ty1 ty2 | Just ty1' <- tcView ty1 = unify subst ty1' ty2
456 unify subst ty1 ty2 | Just ty2' <- tcView ty2 = unify subst ty1 ty2'
458 unify subst (PredTy p1) (PredTy p2) = unify_pred subst p1 p2
460 unify subst (TyConApp tyc1 tys1) (TyConApp tyc2 tys2)
461 | tyc1 == tyc2 = unify_tys subst tys1 tys2
463 unify subst (FunTy ty1a ty1b) (FunTy ty2a ty2b)
464 = do { subst' <- unify subst ty1a ty2a
465 ; unify subst' ty1b ty2b }
467 -- Applications need a bit of care!
468 -- They can match FunTy and TyConApp, so use splitAppTy_maybe
469 -- NB: we've already dealt with type variables and Notes,
470 -- so if one type is an App the other one jolly well better be too
471 unify subst (AppTy ty1a ty1b) ty2
472 | Just (ty2a, ty2b) <- repSplitAppTy_maybe ty2
473 = do { subst' <- unify subst ty1a ty2a
474 ; unify subst' ty1b ty2b }
476 unify subst ty1 (AppTy ty2a ty2b)
477 | Just (ty1a, ty1b) <- repSplitAppTy_maybe ty1
478 = do { subst' <- unify subst ty1a ty2a
479 ; unify subst' ty1b ty2b }
481 unify _ ty1 ty2 = failWith (misMatch ty1 ty2)
484 ------------------------------
485 unify_pred :: TvSubstEnv -> PredType -> PredType -> UM TvSubstEnv
486 unify_pred subst (ClassP c1 tys1) (ClassP c2 tys2)
487 | c1 == c2 = unify_tys subst tys1 tys2
488 unify_pred subst (IParam n1 t1) (IParam n2 t2)
489 | n1 == n2 = unify subst t1 t2
490 unify_pred _ p1 p2 = failWith (misMatch (PredTy p1) (PredTy p2))
492 ------------------------------
493 unify_tys :: TvSubstEnv -> [Type] -> [Type] -> UM TvSubstEnv
494 unify_tys subst xs ys = unifyList subst xs ys
496 unifyList :: TvSubstEnv -> [Type] -> [Type] -> UM TvSubstEnv
497 unifyList subst orig_xs orig_ys
498 = go subst orig_xs orig_ys
500 go subst [] [] = return subst
501 go subst (x:xs) (y:ys) = do { subst' <- unify subst x y
503 go _ _ _ = failWith (lengthMisMatch orig_xs orig_ys)
505 ---------------------------------
506 uVar :: TvSubstEnv -- An existing substitution to extend
507 -> TyVar -- Type variable to be unified
508 -> Type -- with this type
511 -- PRE-CONDITION: in the call (uVar swap r tv1 ty), we know that
512 -- if swap=False (tv1~ty)
513 -- if swap=True (ty~tv1)
516 = -- Check to see whether tv1 is refined by the substitution
517 case (lookupVarEnv subst tv1) of
518 Just ty' -> unify subst ty' ty -- Yes, call back into unify'
519 Nothing -> uUnrefined subst -- No, continue
522 uUnrefined :: TvSubstEnv -- An existing substitution to extend
523 -> TyVar -- Type variable to be unified
524 -> Type -- with this type
525 -> Type -- (version w/ expanded synonyms)
528 -- We know that tv1 isn't refined
530 uUnrefined subst tv1 ty2 ty2'
531 | Just ty2'' <- tcView ty2'
532 = uUnrefined subst tv1 ty2 ty2'' -- Unwrap synonyms
533 -- This is essential, in case we have
535 -- and then unify a ~ Foo a
537 uUnrefined subst tv1 ty2 (TyVarTy tv2)
538 | tv1 == tv2 -- Same type variable
541 -- Check to see whether tv2 is refined
542 | Just ty' <- lookupVarEnv subst tv2
543 = uUnrefined subst tv1 ty' ty'
545 -- So both are unrefined; next, see if the kinds force the direction
546 | eqKind k1 k2 -- Can update either; so check the bind-flags
547 = do { b1 <- tvBindFlag tv1
548 ; b2 <- tvBindFlag tv2
550 (BindMe, _) -> bind tv1 ty2
551 (Skolem, Skolem) -> failWith (misMatch ty1 ty2)
552 (Skolem, _) -> bind tv2 ty1
555 | k1 `isSubKind` k2 = bindTv subst tv2 ty1 -- Must update tv2
556 | k2 `isSubKind` k1 = bindTv subst tv1 ty2 -- Must update tv1
558 | otherwise = failWith (kindMisMatch tv1 ty2)
563 bind tv ty = return $ extendVarEnv subst tv ty
565 uUnrefined subst tv1 ty2 ty2' -- ty2 is not a type variable
566 | tv1 `elemVarSet` niSubstTvSet subst (tyVarsOfType ty2')
567 = failWith (occursCheck tv1 ty2) -- Occurs check
568 | not (k2 `isSubKind` k1)
569 = failWith (kindMisMatch tv1 ty2) -- Kind check
571 = bindTv subst tv1 ty2 -- Bind tyvar to the synonym if poss
576 bindTv :: TvSubstEnv -> TyVar -> Type -> UM TvSubstEnv
577 bindTv subst tv ty -- ty is not a type variable
578 = do { b <- tvBindFlag tv
580 Skolem -> failWith (misMatch (TyVarTy tv) ty)
581 BindMe -> return $ extendVarEnv subst tv ty
585 %************************************************************************
589 %************************************************************************
593 = BindMe -- A regular type variable
595 | Skolem -- This type variable is a skolem constant
596 -- Don't bind it; it only matches itself
600 %************************************************************************
604 %************************************************************************
607 newtype UM a = UM { unUM :: (TyVar -> BindFlag)
608 -> MaybeErr Message a }
610 instance Monad UM where
611 return a = UM (\_tvs -> Succeeded a)
612 fail s = UM (\_tvs -> Failed (text s))
613 m >>= k = UM (\tvs -> case unUM m tvs of
614 Failed err -> Failed err
615 Succeeded v -> unUM (k v) tvs)
617 initUM :: (TyVar -> BindFlag) -> UM a -> MaybeErr Message a
618 initUM badtvs um = unUM um badtvs
620 tvBindFlag :: TyVar -> UM BindFlag
621 tvBindFlag tv = UM (\tv_fn -> Succeeded (tv_fn tv))
623 failWith :: Message -> UM a
624 failWith msg = UM (\_tv_fn -> Failed msg)
626 maybeErrToMaybe :: MaybeErr fail succ -> Maybe succ
627 maybeErrToMaybe (Succeeded a) = Just a
628 maybeErrToMaybe (Failed _) = Nothing
632 %************************************************************************
635 We go to a lot more trouble to tidy the types
636 in TcUnify. Maybe we'll end up having to do that
637 here too, but I'll leave it for now.
639 %************************************************************************
642 misMatch :: Type -> Type -> SDoc
644 = ptext (sLit "Can't match types") <+> quotes (ppr t1) <+>
645 ptext (sLit "and") <+> quotes (ppr t2)
647 lengthMisMatch :: [Type] -> [Type] -> SDoc
648 lengthMisMatch tys1 tys2
649 = sep [ptext (sLit "Can't match unequal length lists"),
650 nest 2 (ppr tys1), nest 2 (ppr tys2) ]
652 kindMisMatch :: TyVar -> Type -> SDoc
654 = vcat [ptext (sLit "Can't match kinds") <+> quotes (ppr (tyVarKind tv1)) <+>
655 ptext (sLit "and") <+> quotes (ppr (typeKind t2)),
656 ptext (sLit "when matching") <+> quotes (ppr tv1) <+>
657 ptext (sLit "with") <+> quotes (ppr t2)]
659 occursCheck :: TyVar -> Type -> SDoc
661 = hang (ptext (sLit "Can't construct the infinite type"))
662 2 (ppr tv <+> equals <+> ppr ty)