Complete work on new OVERLAPPABLE/OVERLAPPING pragmas (Trac #9242)
[ghc.git] / compiler / typecheck / Inst.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 The @Inst@ type: dictionaries or method instances
7
8 \begin{code}
9 {-# LANGUAGE CPP #-}
10 {-# OPTIONS_GHC -fno-warn-tabs #-}
11 -- The above warning supression flag is a temporary kludge.
12 -- While working on this module you are encouraged to remove it and
13 -- detab the module (please do the detabbing in a separate patch). See
14 --     http://ghc.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
15 -- for details
16
17 module Inst ( 
18        deeplySkolemise, 
19        deeplyInstantiate, instCall, instStupidTheta,
20        emitWanted, emitWanteds,
21
22        newOverloadedLit, mkOverLit, 
23      
24        tcGetInsts, tcGetInstEnvs, getOverlapFlag,
25        tcExtendLocalInstEnv, instCallConstraints, newMethodFromName,
26        tcSyntaxName,
27
28        -- Simple functions over evidence variables
29        tyVarsOfWC, tyVarsOfBag, 
30        tyVarsOfCt, tyVarsOfCts, 
31
32        tidyEvVar, tidyCt, tidySkolemInfo
33     ) where
34
35 #include "HsVersions.h"
36
37 import {-# SOURCE #-}   TcExpr( tcPolyExpr, tcSyntaxOp )
38 import {-# SOURCE #-}   TcUnify( unifyType )
39
40 import FastString
41 import HsSyn
42 import TcHsSyn
43 import TcRnMonad
44 import TcEnv
45 import TcEvidence
46 import InstEnv
47 import FunDeps
48 import TcMType
49 import Type
50 import Coercion ( Role(..) )
51 import TcType
52 import HscTypes
53 import Id
54 import Name
55 import Var      ( EvVar, varType, setVarType )
56 import VarEnv
57 import VarSet
58 import PrelNames
59 import SrcLoc
60 import DynFlags
61 import Bag
62 import Util
63 import Outputable
64 import Control.Monad( unless )
65 import Data.List( mapAccumL )
66 \end{code}
67
68
69
70 %************************************************************************
71 %*                                                                      *
72                 Emitting constraints
73 %*                                                                      *
74 %************************************************************************
75
76 \begin{code}
77 emitWanteds :: CtOrigin -> TcThetaType -> TcM [EvVar]
78 emitWanteds origin theta = mapM (emitWanted origin) theta
79
80 emitWanted :: CtOrigin -> TcPredType -> TcM EvVar
81 emitWanted origin pred 
82   = do { loc <- getCtLoc origin
83        ; ev  <- newWantedEvVar pred
84        ; emitFlat $ mkNonCanonical $
85              CtWanted { ctev_pred = pred, ctev_evar = ev, ctev_loc = loc }
86        ; return ev }
87
88 newMethodFromName :: CtOrigin -> Name -> TcRhoType -> TcM (HsExpr TcId)
89 -- Used when Name is the wired-in name for a wired-in class method,
90 -- so the caller knows its type for sure, which should be of form
91 --    forall a. C a => <blah>
92 -- newMethodFromName is supposed to instantiate just the outer 
93 -- type variable and constraint
94
95 newMethodFromName origin name inst_ty
96   = do { id <- tcLookupId name
97               -- Use tcLookupId not tcLookupGlobalId; the method is almost
98               -- always a class op, but with -XRebindableSyntax GHC is
99               -- meant to find whatever thing is in scope, and that may
100               -- be an ordinary function. 
101
102        ; let (tvs, theta, _caller_knows_this) = tcSplitSigmaTy (idType id)
103              (the_tv:rest) = tvs
104              subst = zipOpenTvSubst [the_tv] [inst_ty]
105
106        ; wrap <- ASSERT( null rest && isSingleton theta )
107                  instCall origin [inst_ty] (substTheta subst theta)
108        ; return (mkHsWrap wrap (HsVar id)) }
109 \end{code}
110
111
112 %************************************************************************
113 %*                                                                      *
114         Deep instantiation and skolemisation
115 %*                                                                      *
116 %************************************************************************
117
118 Note [Deep skolemisation]
119 ~~~~~~~~~~~~~~~~~~~~~~~~~
120 deeplySkolemise decomposes and skolemises a type, returning a type
121 with all its arrows visible (ie not buried under foralls)
122
123 Examples:
124
125   deeplySkolemise (Int -> forall a. Ord a => blah)  
126     =  ( wp, [a], [d:Ord a], Int -> blah )
127     where wp = \x:Int. /\a. \(d:Ord a). <hole> x
128
129   deeplySkolemise  (forall a. Ord a => Maybe a -> forall b. Eq b => blah)  
130     =  ( wp, [a,b], [d1:Ord a,d2:Eq b], Maybe a -> blah )
131     where wp = /\a.\(d1:Ord a).\(x:Maybe a)./\b.\(d2:Ord b). <hole> x
132
133 In general,
134   if      deeplySkolemise ty = (wrap, tvs, evs, rho)
135     and   e :: rho
136   then    wrap e :: ty
137     and   'wrap' binds tvs, evs
138
139 ToDo: this eta-abstraction plays fast and loose with termination,
140       because it can introduce extra lambdas.  Maybe add a `seq` to
141       fix this
142
143
144 \begin{code}
145 deeplySkolemise
146   :: TcSigmaType
147   -> TcM (HsWrapper, [TyVar], [EvVar], TcRhoType)
148
149 deeplySkolemise ty
150   | Just (arg_tys, tvs, theta, ty') <- tcDeepSplitSigmaTy_maybe ty
151   = do { ids1 <- newSysLocalIds (fsLit "dk") arg_tys
152        ; (subst, tvs1) <- tcInstSkolTyVars tvs
153        ; ev_vars1 <- newEvVars (substTheta subst theta)
154        ; (wrap, tvs2, ev_vars2, rho) <- deeplySkolemise (substTy subst ty')
155        ; return ( mkWpLams ids1
156                    <.> mkWpTyLams tvs1
157                    <.> mkWpLams ev_vars1
158                    <.> wrap
159                    <.> mkWpEvVarApps ids1
160                 , tvs1     ++ tvs2
161                 , ev_vars1 ++ ev_vars2
162                 , mkFunTys arg_tys rho ) }
163
164   | otherwise
165   = return (idHsWrapper, [], [], ty)
166
167 deeplyInstantiate :: CtOrigin -> TcSigmaType -> TcM (HsWrapper, TcRhoType)
168 --   Int -> forall a. a -> a  ==>  (\x:Int. [] x alpha) :: Int -> alpha
169 -- In general if
170 -- if    deeplyInstantiate ty = (wrap, rho)
171 -- and   e :: ty
172 -- then  wrap e :: rho
173
174 deeplyInstantiate orig ty
175   | Just (arg_tys, tvs, theta, rho) <- tcDeepSplitSigmaTy_maybe ty
176   = do { (_, tys, subst) <- tcInstTyVars tvs
177        ; ids1  <- newSysLocalIds (fsLit "di") (substTys subst arg_tys)
178        ; wrap1 <- instCall orig tys (substTheta subst theta)
179        ; (wrap2, rho2) <- deeplyInstantiate orig (substTy subst rho)
180        ; return (mkWpLams ids1 
181                     <.> wrap2
182                     <.> wrap1 
183                     <.> mkWpEvVarApps ids1,
184                  mkFunTys arg_tys rho2) }
185
186   | otherwise = return (idHsWrapper, ty)
187 \end{code}
188
189
190 %************************************************************************
191 %*                                                                      *
192             Instantiating a call
193 %*                                                                      *
194 %************************************************************************
195
196 \begin{code}
197 ----------------
198 instCall :: CtOrigin -> [TcType] -> TcThetaType -> TcM HsWrapper
199 -- Instantiate the constraints of a call
200 --      (instCall o tys theta)
201 -- (a) Makes fresh dictionaries as necessary for the constraints (theta)
202 -- (b) Throws these dictionaries into the LIE
203 -- (c) Returns an HsWrapper ([.] tys dicts)
204
205 instCall orig tys theta 
206   = do  { dict_app <- instCallConstraints orig theta
207         ; return (dict_app <.> mkWpTyApps tys) }
208
209 ----------------
210 instCallConstraints :: CtOrigin -> TcThetaType -> TcM HsWrapper
211 -- Instantiates the TcTheta, puts all constraints thereby generated
212 -- into the LIE, and returns a HsWrapper to enclose the call site.
213
214 instCallConstraints orig preds
215   | null preds 
216   = return idHsWrapper
217   | otherwise
218   = do { evs <- mapM go preds
219        ; traceTc "instCallConstraints" (ppr evs)
220        ; return (mkWpEvApps evs) }
221   where
222     go pred 
223      | Just (Nominal, ty1, ty2) <- getEqPredTys_maybe pred -- Try short-cut
224      = do  { co <- unifyType ty1 ty2
225            ; return (EvCoercion co) }
226      | otherwise
227      = do { ev_var <- emitWanted orig pred
228           ; return (EvId ev_var) }
229
230 ----------------
231 instStupidTheta :: CtOrigin -> TcThetaType -> TcM ()
232 -- Similar to instCall, but only emit the constraints in the LIE
233 -- Used exclusively for the 'stupid theta' of a data constructor
234 instStupidTheta orig theta
235   = do  { _co <- instCallConstraints orig theta -- Discard the coercion
236         ; return () }
237 \end{code}
238
239 %************************************************************************
240 %*                                                                      *
241                 Literals
242 %*                                                                      *
243 %************************************************************************
244
245 In newOverloadedLit we convert directly to an Int or Integer if we
246 know that's what we want.  This may save some time, by not
247 temporarily generating overloaded literals, but it won't catch all
248 cases (the rest are caught in lookupInst).
249
250 \begin{code}
251 newOverloadedLit :: CtOrigin
252                  -> HsOverLit Name
253                  -> TcRhoType
254                  -> TcM (HsOverLit TcId)
255 newOverloadedLit orig lit res_ty
256     = do dflags <- getDynFlags
257          newOverloadedLit' dflags orig lit res_ty
258
259 newOverloadedLit' :: DynFlags
260                   -> CtOrigin
261                   -> HsOverLit Name
262                   -> TcRhoType
263                   -> TcM (HsOverLit TcId)
264 newOverloadedLit' dflags orig
265   lit@(OverLit { ol_val = val, ol_rebindable = rebindable
266                , ol_witness = meth_name }) res_ty
267
268   | not rebindable
269   , Just expr <- shortCutLit dflags val res_ty 
270         -- Do not generate a LitInst for rebindable syntax.  
271         -- Reason: If we do, tcSimplify will call lookupInst, which
272         --         will call tcSyntaxName, which does unification, 
273         --         which tcSimplify doesn't like
274   = return (lit { ol_witness = expr, ol_type = res_ty })
275
276   | otherwise
277   = do  { hs_lit <- mkOverLit val
278         ; let lit_ty = hsLitType hs_lit
279         ; fi' <- tcSyntaxOp orig meth_name (mkFunTy lit_ty res_ty)
280                 -- Overloaded literals must have liftedTypeKind, because
281                 -- we're instantiating an overloaded function here,
282                 -- whereas res_ty might be openTypeKind. This was a bug in 6.2.2
283                 -- However this'll be picked up by tcSyntaxOp if necessary
284         ; let witness = HsApp (noLoc fi') (noLoc (HsLit hs_lit))
285         ; return (lit { ol_witness = witness, ol_type = res_ty }) }
286
287 ------------
288 mkOverLit :: OverLitVal -> TcM HsLit
289 mkOverLit (HsIntegral i) 
290   = do  { integer_ty <- tcMetaTy integerTyConName
291         ; return (HsInteger i integer_ty) }
292
293 mkOverLit (HsFractional r)
294   = do  { rat_ty <- tcMetaTy rationalTyConName
295         ; return (HsRat r rat_ty) }
296
297 mkOverLit (HsIsString s) = return (HsString s)
298 \end{code}
299
300
301
302
303 %************************************************************************
304 %*                                                                      *
305                 Re-mappable syntax
306     
307      Used only for arrow syntax -- find a way to nuke this
308 %*                                                                      *
309 %************************************************************************
310
311 Suppose we are doing the -XRebindableSyntax thing, and we encounter
312 a do-expression.  We have to find (>>) in the current environment, which is
313 done by the rename. Then we have to check that it has the same type as
314 Control.Monad.(>>).  Or, more precisely, a compatible type. One 'customer' had
315 this:
316
317   (>>) :: HB m n mn => m a -> n b -> mn b
318
319 So the idea is to generate a local binding for (>>), thus:
320
321         let then72 :: forall a b. m a -> m b -> m b
322             then72 = ...something involving the user's (>>)...
323         in
324         ...the do-expression...
325
326 Now the do-expression can proceed using then72, which has exactly
327 the expected type.
328
329 In fact tcSyntaxName just generates the RHS for then72, because we only
330 want an actual binding in the do-expression case. For literals, we can 
331 just use the expression inline.
332
333 \begin{code}
334 tcSyntaxName :: CtOrigin
335              -> TcType                  -- Type to instantiate it at
336              -> (Name, HsExpr Name)     -- (Standard name, user name)
337              -> TcM (Name, HsExpr TcId) -- (Standard name, suitable expression)
338 -- USED ONLY FOR CmdTop (sigh) ***
339 -- See Note [CmdSyntaxTable] in HsExpr
340
341 tcSyntaxName orig ty (std_nm, HsVar user_nm)
342   | std_nm == user_nm
343   = do rhs <- newMethodFromName orig std_nm ty
344        return (std_nm, rhs)
345
346 tcSyntaxName orig ty (std_nm, user_nm_expr) = do
347     std_id <- tcLookupId std_nm
348     let 
349         -- C.f. newMethodAtLoc
350         ([tv], _, tau)  = tcSplitSigmaTy (idType std_id)
351         sigma1          = substTyWith [tv] [ty] tau
352         -- Actually, the "tau-type" might be a sigma-type in the
353         -- case of locally-polymorphic methods.
354
355     addErrCtxtM (syntaxNameCtxt user_nm_expr orig sigma1) $ do
356
357         -- Check that the user-supplied thing has the
358         -- same type as the standard one.  
359         -- Tiresome jiggling because tcCheckSigma takes a located expression
360      span <- getSrcSpanM
361      expr <- tcPolyExpr (L span user_nm_expr) sigma1
362      return (std_nm, unLoc expr)
363
364 syntaxNameCtxt :: HsExpr Name -> CtOrigin -> Type -> TidyEnv
365                -> TcRn (TidyEnv, SDoc)
366 syntaxNameCtxt name orig ty tidy_env
367   = do { inst_loc <- getCtLoc orig
368        ; let msg = vcat [ ptext (sLit "When checking that") <+> quotes (ppr name)
369                           <+> ptext (sLit "(needed by a syntactic construct)")
370                         , nest 2 (ptext (sLit "has the required type:")
371                                   <+> ppr (tidyType tidy_env ty))
372                         , nest 2 (pprArisingAt inst_loc) ]
373        ; return (tidy_env, msg) }
374 \end{code}
375
376
377 %************************************************************************
378 %*                                                                      *
379                 Instances
380 %*                                                                      *
381 %************************************************************************
382
383 \begin{code}
384 getOverlapFlag :: TcM OverlapFlag
385 getOverlapFlag
386   = do  { dflags <- getDynFlags
387         ; let overlap_ok    = xopt Opt_OverlappingInstances dflags
388               incoherent_ok = xopt Opt_IncoherentInstances  dflags
389               use x = OverlapFlag { isSafeOverlap = safeLanguageOn dflags
390                                   , overlapMode   = x }
391               overlap_flag | incoherent_ok = use Incoherent
392                            | overlap_ok    = use Overlaps
393                            | otherwise     = use NoOverlap
394
395         ; return overlap_flag }
396
397 tcGetInstEnvs :: TcM (InstEnv, InstEnv)
398 -- Gets both the external-package inst-env
399 -- and the home-pkg inst env (includes module being compiled)
400 tcGetInstEnvs = do { eps <- getEps; env <- getGblEnv;
401                      return (eps_inst_env eps, tcg_inst_env env) }
402
403 tcGetInsts :: TcM [ClsInst]
404 -- Gets the local class instances.
405 tcGetInsts = fmap tcg_insts getGblEnv
406
407 tcExtendLocalInstEnv :: [ClsInst] -> TcM a -> TcM a
408   -- Add new locally-defined instances
409 tcExtendLocalInstEnv dfuns thing_inside
410  = do { traceDFuns dfuns
411       ; env <- getGblEnv
412       ; (inst_env', cls_insts') <- foldlM addLocalInst
413                                           (tcg_inst_env env, tcg_insts env)
414                                           dfuns
415       ; let env' = env { tcg_insts    = cls_insts'
416                        , tcg_inst_env = inst_env' }
417       ; setGblEnv env' thing_inside }
418
419 addLocalInst :: (InstEnv, [ClsInst]) -> ClsInst -> TcM (InstEnv, [ClsInst])
420 -- Check that the proposed new instance is OK,
421 -- and then add it to the home inst env
422 -- If overwrite_inst, then we can overwrite a direct match
423 addLocalInst (home_ie, my_insts) ispec
424    = do {
425          -- Instantiate the dfun type so that we extend the instance
426          -- envt with completely fresh template variables
427          -- This is important because the template variables must
428          -- not overlap with anything in the things being looked up
429          -- (since we do unification).
430              --
431              -- We use tcInstSkolType because we don't want to allocate fresh
432              --  *meta* type variables.
433              --
434              -- We use UnkSkol --- and *not* InstSkol or PatSkol --- because
435              -- these variables must be bindable by tcUnifyTys.  See
436              -- the call to tcUnifyTys in InstEnv, and the special
437              -- treatment that instanceBindFun gives to isOverlappableTyVar
438              -- This is absurdly delicate.
439
440              -- Load imported instances, so that we report
441              -- duplicates correctly
442
443              -- 'matches'  are existing instance declarations that are less
444              --            specific than the new one
445              -- 'dups'     are those 'matches' that are equal to the new one
446          ; isGHCi <- getIsGHCi
447          ; eps    <- getEps
448          ; let (home_ie', my_insts')
449                  | isGHCi    = ( deleteFromInstEnv home_ie ispec
450                                , filterOut (identicalInstHead ispec) my_insts)
451                  | otherwise = (home_ie, my_insts)
452                -- If there is a home-package duplicate instance,
453                -- silently delete it
454
455                (_tvs, cls, tys) = instanceHead ispec
456                inst_envs       = (eps_inst_env eps, home_ie')
457                (matches, _, _) = lookupInstEnv inst_envs cls tys
458                dups            = filter (identicalInstHead ispec) (map fst matches)
459
460              -- Check functional dependencies
461          ; case checkFunDeps inst_envs ispec of
462              Just specs -> funDepErr ispec specs
463              Nothing    -> return ()
464
465              -- Check for duplicate instance decls
466          ; unless (null dups) $
467            dupInstErr ispec (head dups)
468
469          ; return (extendInstEnv home_ie' ispec, ispec:my_insts') }
470
471 traceDFuns :: [ClsInst] -> TcRn ()
472 traceDFuns ispecs
473   = traceTc "Adding instances:" (vcat (map pp ispecs))
474   where
475     pp ispec = hang (ppr (instanceDFunId ispec) <+> colon)
476                   2 (ppr ispec)
477         -- Print the dfun name itself too
478
479 funDepErr :: ClsInst -> [ClsInst] -> TcRn ()
480 funDepErr ispec ispecs
481   = addClsInstsErr (ptext (sLit "Functional dependencies conflict between instance declarations:"))
482                     (ispec : ispecs)
483
484 dupInstErr :: ClsInst -> ClsInst -> TcRn ()
485 dupInstErr ispec dup_ispec
486   = addClsInstsErr (ptext (sLit "Duplicate instance declarations:"))
487                     [ispec, dup_ispec]
488
489 addClsInstsErr :: SDoc -> [ClsInst] -> TcRn ()
490 addClsInstsErr herald ispecs
491   = setSrcSpan (getSrcSpan (head sorted)) $
492     addErr (hang herald 2 (pprInstances sorted))
493  where
494    sorted = sortWith getSrcLoc ispecs
495    -- The sortWith just arranges that instances are dislayed in order
496    -- of source location, which reduced wobbling in error messages,
497    -- and is better for users
498 \end{code}
499
500 %************************************************************************
501 %*                                                                      *
502         Simple functions over evidence variables
503 %*                                                                      *
504 %************************************************************************
505
506 \begin{code}
507 ---------------- Getting free tyvars -------------------------
508 tyVarsOfCt :: Ct -> TcTyVarSet
509 -- NB: the 
510 tyVarsOfCt (CTyEqCan { cc_tyvar = tv, cc_rhs = xi })    = extendVarSet (tyVarsOfType xi) tv
511 tyVarsOfCt (CFunEqCan { cc_tyargs = tys, cc_rhs = xi }) = tyVarsOfTypes (xi:tys)
512 tyVarsOfCt (CDictCan { cc_tyargs = tys })               = tyVarsOfTypes tys
513 tyVarsOfCt (CIrredEvCan { cc_ev = ev })                 = tyVarsOfType (ctEvPred ev)
514 tyVarsOfCt (CHoleCan { cc_ev = ev })                    = tyVarsOfType (ctEvPred ev)
515 tyVarsOfCt (CNonCanonical { cc_ev = ev })               = tyVarsOfType (ctEvPred ev)
516
517 tyVarsOfCts :: Cts -> TcTyVarSet
518 tyVarsOfCts = foldrBag (unionVarSet . tyVarsOfCt) emptyVarSet
519
520 tyVarsOfWC :: WantedConstraints -> TyVarSet
521 -- Only called on *zonked* things, hence no need to worry about flatten-skolems
522 tyVarsOfWC (WC { wc_flat = flat, wc_impl = implic, wc_insol = insol })
523   = tyVarsOfCts flat `unionVarSet`
524     tyVarsOfBag tyVarsOfImplic implic `unionVarSet`
525     tyVarsOfCts insol
526
527 tyVarsOfImplic :: Implication -> TyVarSet
528 -- Only called on *zonked* things, hence no need to worry about flatten-skolems
529 tyVarsOfImplic (Implic { ic_skols = skols, ic_fsks = fsks
530                              , ic_given = givens, ic_wanted = wanted })
531   = (tyVarsOfWC wanted `unionVarSet` tyVarsOfTypes (map evVarPred givens))
532     `delVarSetList` skols `delVarSetList` fsks
533
534 tyVarsOfBag :: (a -> TyVarSet) -> Bag a -> TyVarSet
535 tyVarsOfBag tvs_of = foldrBag (unionVarSet . tvs_of) emptyVarSet
536
537 ---------------- Tidying -------------------------
538
539 tidyCt :: TidyEnv -> Ct -> Ct
540 -- Used only in error reporting
541 -- Also converts it to non-canonical
542 tidyCt env ct 
543   = case ct of
544      CHoleCan { cc_ev = ev }
545        -> ct { cc_ev = tidy_ev env ev }
546      _ -> mkNonCanonical (tidy_ev env (ctEvidence ct))
547   where 
548     tidy_ev :: TidyEnv -> CtEvidence -> CtEvidence
549      -- NB: we do not tidy the ctev_evtm/var field because we don't 
550      --     show it in error messages
551     tidy_ev env ctev@(CtGiven { ctev_pred = pred })
552       = ctev { ctev_pred = tidyType env pred }
553     tidy_ev env ctev@(CtWanted { ctev_pred = pred })
554       = ctev { ctev_pred = tidyType env pred }
555     tidy_ev env ctev@(CtDerived { ctev_pred = pred })
556       = ctev { ctev_pred = tidyType env pred }
557
558 tidyEvVar :: TidyEnv -> EvVar -> EvVar
559 tidyEvVar env var = setVarType var (tidyType env (varType var))
560
561 tidySkolemInfo :: TidyEnv -> SkolemInfo -> (TidyEnv, SkolemInfo)
562 tidySkolemInfo env (SigSkol cx ty) 
563   = (env', SigSkol cx ty')
564   where
565     (env', ty') = tidyOpenType env ty
566
567 tidySkolemInfo env (InferSkol ids) 
568   = (env', InferSkol ids')
569   where
570     (env', ids') = mapAccumL do_one env ids
571     do_one env (name, ty) = (env', (name, ty'))
572        where
573          (env', ty') = tidyOpenType env ty
574
575 tidySkolemInfo env (UnifyForAllSkol skol_tvs ty) 
576   = (env1, UnifyForAllSkol skol_tvs' ty')
577   where
578     env1 = tidyFreeTyVars env (tyVarsOfType ty `delVarSetList` skol_tvs)
579     (env2, skol_tvs') = tidyTyVarBndrs env1 skol_tvs
580     ty'               = tidyType env2 ty
581
582 tidySkolemInfo env info = (env, info)
583 \end{code}