2 % (c) The University of Glasgow 2006
3 % (c) The GRASP Project, Glasgow University, 1992-2002
7 TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
10 -- The environment types
12 TcGblEnv(..), TcLclEnv(..),
13 IfGblEnv(..), IfLclEnv(..),
16 ErrCtxt, RecFieldEnv(..),
17 ImportAvails(..), emptyImportAvails, plusImportAvails,
18 WhereFrom(..), mkModDeps,
21 TcTypeEnv, TcTyThing(..), pprTcTyThingCategory,
24 ThStage(..), topStage, topAnnStage, topSpliceStage,
25 ThLevel, impLevel, outerLevel, thLevel,
28 ArrowCtxt(NoArrowCtxt), newArrowScope, escapeArrowScope,
32 WantedConstraints, emptyWanteds, andWanteds, extendWanteds,
33 WantedConstraint(..), WantedEvVar(..), wantedEvVarLoc,
34 wantedEvVarToVar, wantedEvVarPred, splitWanteds,
38 CtLoc(..), ctLocSpan, ctLocOrigin, setCtLocOrigin,
39 CtOrigin(..), EqOrigin(..),
45 pprEvVarTheta, pprWantedsWithLocs, pprWantedWithLoc,
46 pprEvVars, pprEvVarWithType,
47 pprArising, pprArisingAt,
50 TcId, TcIdSet, TcTyVarBind(..), TcTyVarBinds
54 #include "HsVersions.h"
81 import StaticFlags( opt_ErrorSpans )
87 %************************************************************************
89 Standard monad definition for TcRn
90 All the combinators for the monad can be found in TcRnMonad
92 %************************************************************************
94 The monad itself has to be defined here, because it is mentioned by ErrCtxt
97 type TcRef a = IORef a
98 type TcId = Id -- Type may be a TcType DV: WHAT??????????
102 type TcRnIf a b c = IOEnv (Env a b) c
103 type IfM lcl a = TcRnIf IfGblEnv lcl a -- Iface stuff
105 type IfG a = IfM () a -- Top level
106 type IfL a = IfM IfLclEnv a -- Nested
107 type TcRn a = TcRnIf TcGblEnv TcLclEnv a
108 type RnM a = TcRn a -- Historical
109 type TcM a = TcRn a -- Historical
112 Representation of type bindings to uninstantiated meta variables used during
116 data TcTyVarBind = TcTyVarBind TcTyVar TcType
118 type TcTyVarBinds = Bag TcTyVarBind
120 instance Outputable TcTyVarBind where
121 ppr (TcTyVarBind tv ty) = ppr tv <+> text ":=" <+> ppr ty
125 %************************************************************************
127 The main environment types
129 %************************************************************************
132 data Env gbl lcl -- Changes as we move into an expression
134 env_top :: HscEnv, -- Top-level stuff that never changes
135 -- Includes all info about imported things
137 env_us :: {-# UNPACK #-} !(IORef UniqSupply),
138 -- Unique supply for local varibles
140 env_gbl :: gbl, -- Info about things defined at the top level
141 -- of the module being compiled
143 env_lcl :: lcl -- Nested stuff; changes as we go into
146 -- TcGblEnv describes the top-level of the module at the
147 -- point at which the typechecker is finished work.
148 -- It is this structure that is handed on to the desugarer
152 tcg_mod :: Module, -- ^ Module being compiled
153 tcg_src :: HscSource,
154 -- ^ What kind of module (regular Haskell, hs-boot, ext-core)
156 tcg_rdr_env :: GlobalRdrEnv, -- ^ Top level envt; used during renaming
157 tcg_default :: Maybe [Type],
158 -- ^ Types used for defaulting. @Nothing@ => no @default@ decl
160 tcg_fix_env :: FixityEnv, -- ^ Just for things in this module
161 tcg_field_env :: RecFieldEnv, -- ^ Just for things in this module
163 tcg_type_env :: TypeEnv,
164 -- ^ Global type env for the module we are compiling now. All
165 -- TyCons and Classes (for this module) end up in here right away,
166 -- along with their derived constructors, selectors.
168 -- (Ids defined in this module start in the local envt, though they
169 -- move to the global envt during zonking)
171 tcg_type_env_var :: TcRef TypeEnv,
172 -- Used only to initialise the interface-file
173 -- typechecker in initIfaceTcRn, so that it can see stuff
174 -- bound in this module when dealing with hi-boot recursions
175 -- Updated at intervals (e.g. after dealing with types and classes)
177 tcg_inst_env :: InstEnv,
178 -- ^ Instance envt for /home-package/ modules; Includes the dfuns in
180 tcg_fam_inst_env :: FamInstEnv, -- ^ Ditto for family instances
182 -- Now a bunch of things about this module that are simply
183 -- accumulated, but never consulted until the end.
184 -- Nevertheless, it's convenient to accumulate them along
185 -- with the rest of the info from this module.
186 tcg_exports :: [AvailInfo], -- ^ What is exported
187 tcg_imports :: ImportAvails,
188 -- ^ Information about what was imported from where, including
189 -- things bound in this module.
192 -- ^ What is defined in this module and what is used.
193 -- The latter is used to generate
195 -- (a) version tracking; no need to recompile if these things have
196 -- not changed version stamp
198 -- (b) unused-import info
200 tcg_keep :: TcRef NameSet,
201 -- ^ Locally-defined top-level names to keep alive.
203 -- "Keep alive" means give them an Exported flag, so that the
204 -- simplifier does not discard them as dead code, and so that they
205 -- are exposed in the interface file (but not to export to the
208 -- Some things, like dict-fun Ids and default-method Ids are "born"
209 -- with the Exported flag on, for exactly the above reason, but some
210 -- we only discover as we go. Specifically:
212 -- * The to/from functions for generic data types
214 -- * Top-level variables appearing free in the RHS of an orphan
217 -- * Top-level variables appearing free in a TH bracket
219 tcg_inst_uses :: TcRef NameSet,
220 -- ^ Home-package Dfuns actually used.
222 -- Used to generate version dependencies This records usages, rather
223 -- like tcg_dus, but it has to be a mutable variable so it can be
224 -- augmented when we look up an instance. These uses of dfuns are
225 -- rather like the free variables of the program, but are implicit
226 -- instead of explicit.
228 tcg_th_used :: TcRef Bool,
229 -- ^ @True@ <=> Template Haskell syntax used.
231 -- We need this so that we can generate a dependency on the Template
232 -- Haskell package, becuase the desugarer is going to emit loads of
233 -- references to TH symbols. It's rather like tcg_inst_uses; the
234 -- reference is implicit rather than explicit, so we have to zap a
237 tcg_dfun_n :: TcRef OccSet,
238 -- ^ Allows us to choose unique DFun names.
240 -- The next fields accumulate the payload of the module
241 -- The binds, rules and foreign-decl fiels are collected
242 -- initially in un-zonked form and are finally zonked in tcRnSrcDecls
244 tcg_rn_exports :: Maybe [Located (IE Name)],
245 tcg_rn_imports :: [LImportDecl Name],
246 -- Keep the renamed imports regardless. They are not
247 -- voluminous and are needed if you want to report unused imports
249 tcg_used_rdrnames :: TcRef (Set RdrName),
250 -- The set of used *imported* (not locally-defined) RdrNames
251 -- Used only to report unused import declarations
253 tcg_rn_decls :: Maybe (HsGroup Name),
254 -- ^ Renamed decls, maybe. @Nothing@ <=> Don't retain renamed
257 tcg_ev_binds :: Bag EvBind, -- Top-level evidence bindings
258 tcg_binds :: LHsBinds Id, -- Value bindings in this module
259 tcg_warns :: Warnings, -- ...Warnings and deprecations
260 tcg_anns :: [Annotation], -- ...Annotations
261 tcg_insts :: [Instance], -- ...Instances
262 tcg_fam_insts :: [FamInst], -- ...Family instances
263 tcg_rules :: [LRuleDecl Id], -- ...Rules
264 tcg_fords :: [LForeignDecl Id], -- ...Foreign import & exports
266 tcg_doc_hdr :: Maybe LHsDocString, -- ^ Maybe Haddock header docs
267 tcg_hpc :: AnyHpcUsage, -- ^ @True@ if any part of the
268 -- prog uses hpc instrumentation.
270 tcg_main :: Maybe Name -- ^ The Name of the main
271 -- function, if this module is
276 = RecFields (NameEnv [Name]) -- Maps a constructor name *in this module*
277 -- to the fields for that constructor
278 NameSet -- Set of all fields declared *in this module*;
279 -- used to suppress name-shadowing complaints
280 -- when using record wild cards
281 -- E.g. let fld = e in C {..}
282 -- This is used when dealing with ".." notation in record
283 -- construction and pattern matching.
284 -- The FieldEnv deals *only* with constructors defined in *this*
285 -- module. For imported modules, we get the same info from the
289 %************************************************************************
291 The interface environments
292 Used when dealing with IfaceDecls
294 %************************************************************************
299 -- The type environment for the module being compiled,
300 -- in case the interface refers back to it via a reference that
301 -- was originally a hi-boot file.
302 -- We need the module name so we can test when it's appropriate
303 -- to look in this env.
304 if_rec_types :: Maybe (Module, IfG TypeEnv)
305 -- Allows a read effect, so it can be in a mutable
306 -- variable; c.f. handling the external package type env
307 -- Nothing => interactive stuff, no loops possible
312 -- The module for the current IfaceDecl
313 -- So if we see f = \x -> x
314 -- it means M.f = \x -> x, where M is the if_mod
317 -- The field is used only for error reporting
318 -- if (say) there's a Lint error in it
320 -- Where the interface came from:
321 -- .hi file, or GHCi state, or ext core
322 -- plus which bit is currently being examined
324 if_tv_env :: UniqFM TyVar, -- Nested tyvar bindings
325 if_id_env :: UniqFM Id -- Nested id binding
330 %************************************************************************
332 The local typechecker environment
334 %************************************************************************
336 The Global-Env/Local-Env story
337 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
338 During type checking, we keep in the tcg_type_env
339 * All types and classes
340 * All Ids derived from types and classes (constructors, selectors)
342 At the end of type checking, we zonk the local bindings,
343 and as we do so we add to the tcg_type_env
344 * Locally defined top-level Ids
346 Why? Because they are now Ids not TcIds. This final GlobalEnv is
347 a) fed back (via the knot) to typechecking the
348 unfoldings of interface signatures
349 b) used in the ModDetails of this module
352 data TcLclEnv -- Changes as we move inside an expression
353 -- Discarded after typecheck/rename; not passed on to desugarer
355 tcl_loc :: SrcSpan, -- Source span
356 tcl_ctxt :: [ErrCtxt], -- Error context, innermost on top
357 tcl_errs :: TcRef Messages, -- Place to accumulate errors
359 tcl_th_ctxt :: ThStage, -- Template Haskell context
360 tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context
362 tcl_rdr :: LocalRdrEnv, -- Local name envt
363 -- Maintained during renaming, of course, but also during
364 -- type checking, solely so that when renaming a Template-Haskell
365 -- splice we have the right environment for the renamer.
367 -- Does *not* include global name envt; may shadow it
368 -- Includes both ordinary variables and type variables;
369 -- they are kept distinct because tyvar have a different
370 -- occurrence contructor (Name.TvOcc)
371 -- We still need the unsullied global name env so that
372 -- we can look up record field names
374 tcl_env :: TcTypeEnv, -- The local type environment: Ids and
375 -- TyVars defined in this module
377 tcl_tyvars :: TcRef TcTyVarSet, -- The "global tyvars"
378 -- Namely, the in-scope TyVars bound in tcl_env,
379 -- plus the tyvars mentioned in the types of Ids bound
381 -- Why mutable? see notes with tcGetGlobalTyVars
383 tcl_lie :: TcRef WantedConstraints, -- Place to accumulate type constraints
384 tcl_untch :: Untouchables -- Untouchables
387 type TcTypeEnv = NameEnv TcTyThing
390 {- Note [Given Insts]
392 Because of GADTs, we have to pass inwards the Insts provided by type signatures
393 and existential contexts. Consider
394 data T a where { T1 :: b -> b -> T [b] }
395 f :: Eq a => T a -> Bool
396 f (T1 x y) = [x]==[y]
398 The constructor T1 binds an existential variable 'b', and we need Eq [b].
399 Well, we have it, because Eq a refines to Eq [b], but we can only spot that if we
404 ---------------------------
405 -- Template Haskell stages and levels
406 ---------------------------
408 data ThStage -- See Note [Template Haskell state diagram] in TcSplice
409 = Splice -- Top-level splicing
410 -- This code will be run *at compile time*;
411 -- the result replaces the splice
414 | Comp -- Ordinary Haskell code
417 | Brack -- Inside brackets
418 ThStage -- Binding level = level(stage) + 1
419 (TcRef [PendingSplice]) -- Accumulate pending splices here
420 (TcRef WantedConstraints) -- and type constraints here
422 topStage, topAnnStage, topSpliceStage :: ThStage
425 topSpliceStage = Splice
427 instance Outputable ThStage where
428 ppr Splice = text "Splice"
429 ppr Comp = text "Comp"
430 ppr (Brack s _ _) = text "Brack" <> parens (ppr s)
433 -- See Note [Template Haskell levels] in TcSplice
434 -- Incremented when going inside a bracket,
435 -- decremented when going inside a splice
436 -- NB: ThLevel is one greater than the 'n' in Fig 2 of the
437 -- original "Template meta-programming for Haskell" paper
439 impLevel, outerLevel :: ThLevel
440 impLevel = 0 -- Imported things; they can be used inside a top level splice
441 outerLevel = 1 -- Things defined outside brackets
442 -- NB: Things at level 0 are not *necessarily* imported.
443 -- eg $( \b -> ... ) here b is bound at level 0
447 -- g1 = $(map ...) is OK
448 -- g2 = $(f ...) is not OK; because we havn't compiled f yet
450 thLevel :: ThStage -> ThLevel
453 thLevel (Brack s _ _) = thLevel s + 1
455 ---------------------------
456 -- Arrow-notation context
457 ---------------------------
460 In arrow notation, a variable bound by a proc (or enclosed let/kappa)
461 is not in scope to the left of an arrow tail (-<) or the head of (|..|).
466 Here, x is not in scope in e1, but it is in scope in e2. This can get
470 proc y -> (proc z -> e1) -< e2
472 Here, x and z are in scope in e1, but y is not. We implement this by
473 recording the environment when passing a proc (using newArrowScope),
474 and returning to that (using escapeArrowScope) on the left of -< and the
480 | ArrowCtxt (Env TcGblEnv TcLclEnv)
482 -- Record the current environment (outside a proc)
483 newArrowScope :: TcM a -> TcM a
486 env { env_lcl = (env_lcl env) { tcl_arrow_ctxt = ArrowCtxt env } }
488 -- Return to the stored environment (from the enclosing proc)
489 escapeArrowScope :: TcM a -> TcM a
491 = updEnv $ \ env -> case tcl_arrow_ctxt (env_lcl env) of
493 ArrowCtxt env' -> env'
495 ---------------------------
497 ---------------------------
500 = AGlobal TyThing -- Used only in the return type of a lookup
502 | ATcId { -- Ids defined in this module; may not be fully zonked
504 tct_level :: ThLevel }
506 | ATyVar Name TcType -- The type to which the lexically scoped type vaiable
507 -- is currently refined. We only need the Name
508 -- for error-message purposes; it is the corresponding
509 -- Name in the domain of the envt
511 | AThing TcKind -- Used temporarily, during kind checking, for the
512 -- tycons and clases in this recursive group
514 instance Outputable TcTyThing where -- Debugging only
515 ppr (AGlobal g) = pprTyThing g
516 ppr elt@(ATcId {}) = text "Identifier" <>
517 brackets (ppr (tct_id elt) <> dcolon
518 <> ppr (varType (tct_id elt)) <> comma
519 <+> ppr (tct_level elt))
520 ppr (ATyVar tv _) = text "Type variable" <+> quotes (ppr tv)
521 ppr (AThing k) = text "AThing" <+> ppr k
523 pprTcTyThingCategory :: TcTyThing -> SDoc
524 pprTcTyThingCategory (AGlobal thing) = pprTyThingCategory thing
525 pprTcTyThingCategory (ATyVar {}) = ptext (sLit "Type variable")
526 pprTcTyThingCategory (ATcId {}) = ptext (sLit "Local identifier")
527 pprTcTyThingCategory (AThing {}) = ptext (sLit "Kinded thing")
531 type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, Message))
532 -- Monadic so that we have a chance
533 -- to deal with bound type variables just before error
534 -- message construction
536 -- Bool: True <=> this is a landmark context; do not
537 -- discard it when trimming for display
541 %************************************************************************
543 Operations over ImportAvails
545 %************************************************************************
548 -- | 'ImportAvails' summarises what was imported from where, irrespective of
549 -- whether the imported things are actually used or not. It is used:
551 -- * when processing the export list,
553 -- * when constructing usage info for the interface file,
555 -- * to identify the list of directly imported modules for initialisation
556 -- purposes and for optimised overlap checking of family instances,
558 -- * when figuring out what things are really unused
562 imp_mods :: ModuleEnv [(ModuleName, Bool, SrcSpan)],
563 -- ^ Domain is all directly-imported modules
564 -- The 'ModuleName' is what the module was imported as, e.g. in
572 -- - @True@ => import was @import Foo ()@
574 -- - @False@ => import was some other form
578 -- (a) to help construct the usage information in the interface
579 -- file; if we import somethign we need to recompile if the
580 -- export version changes
582 -- (b) to specify what child modules to initialise
584 -- We need a full ModuleEnv rather than a ModuleNameEnv here,
585 -- because we might be importing modules of the same name from
586 -- different packages. (currently not the case, but might be in the
589 imp_dep_mods :: ModuleNameEnv (ModuleName, IsBootInterface),
590 -- ^ Home-package modules needed by the module being compiled
592 -- It doesn't matter whether any of these dependencies
593 -- are actually /used/ when compiling the module; they
594 -- are listed if they are below it at all. For
595 -- example, suppose M imports A which imports X. Then
596 -- compiling M might not need to consult X.hi, but X
597 -- is still listed in M's dependencies.
599 imp_dep_pkgs :: [PackageId],
600 -- ^ Packages needed by the module being compiled, whether directly,
601 -- or via other modules in this package, or via modules imported
602 -- from other packages.
604 imp_orphs :: [Module],
605 -- ^ Orphan modules below us in the import tree (and maybe including
606 -- us for imported modules)
608 imp_finsts :: [Module]
609 -- ^ Family instance modules below us in the import tree (and maybe
610 -- including us for imported modules)
613 mkModDeps :: [(ModuleName, IsBootInterface)]
614 -> ModuleNameEnv (ModuleName, IsBootInterface)
615 mkModDeps deps = foldl add emptyUFM deps
617 add env elt@(m,_) = addToUFM env m elt
619 emptyImportAvails :: ImportAvails
620 emptyImportAvails = ImportAvails { imp_mods = emptyModuleEnv,
621 imp_dep_mods = emptyUFM,
626 plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
628 (ImportAvails { imp_mods = mods1,
629 imp_dep_mods = dmods1, imp_dep_pkgs = dpkgs1,
630 imp_orphs = orphs1, imp_finsts = finsts1 })
631 (ImportAvails { imp_mods = mods2,
632 imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
633 imp_orphs = orphs2, imp_finsts = finsts2 })
634 = ImportAvails { imp_mods = plusModuleEnv_C (++) mods1 mods2,
635 imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2,
636 imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2,
637 imp_orphs = orphs1 `unionLists` orphs2,
638 imp_finsts = finsts1 `unionLists` finsts2 }
640 plus_mod_dep (m1, boot1) (m2, boot2)
641 = WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
642 -- Check mod-names match
643 (m1, boot1 && boot2) -- If either side can "see" a non-hi-boot interface, use that
646 %************************************************************************
648 \subsection{Where from}
650 %************************************************************************
652 The @WhereFrom@ type controls where the renamer looks for an interface file
656 = ImportByUser IsBootInterface -- Ordinary user import (perhaps {-# SOURCE #-})
657 | ImportBySystem -- Non user import.
659 instance Outputable WhereFrom where
660 ppr (ImportByUser is_boot) | is_boot = ptext (sLit "{- SOURCE -}")
662 ppr ImportBySystem = ptext (sLit "{- SYSTEM -}")
666 %************************************************************************
670 These are forced to be in TcRnTypes because
671 TcLclEnv mentions WantedConstraints
672 WantedConstraint mentions CtLoc
673 CtLoc mentions ErrCtxt
676 v%************************************************************************
679 type Untouchables = TcTyVarSet -- All MetaTyVars
681 type WantedConstraints = Bag WantedConstraint
683 data WantedConstraint
684 = WcEvVar WantedEvVar
685 | WcImplic Implication
686 -- ToDo: add literals, methods
688 -- EvVar defined in module Var.lhs:
689 -- Evidence variables include all *quantifiable* constraints
691 -- implicit parameters
692 -- coercion variables
694 data WantedEvVar -- The sort of constraint over which one can lambda-abstract
696 EvVar -- The variable itself; make a binding for it please
697 WantedLoc -- How the constraint arose in the first place
698 -- (used for error messages only)
700 type WantedLoc = CtLoc CtOrigin
701 type GivenLoc = CtLoc SkolemInfo
705 ic_env_tvs :: Untouchables, -- Untouchables: unification variables
706 -- free in the environment
707 ic_env :: TcTypeEnv, -- The type environment
708 -- Used only when generating error messages
709 -- Generally, ic_env_tvs = tvsof(ic_env)
710 -- However, we don't zonk ic_env when zonking the Implication
711 -- Instead we do that when generating a skolem-escape error message
713 ic_skols :: TcTyVarSet, -- Introduced skolems
714 -- See Note [Skolems in an implication]
716 ic_scoped :: [TcTyVar], -- List of scoped variables to be unified
717 -- bijectively to a subset of ic_tyvars
718 -- Note [Scoped pattern variable]
720 ic_given :: [EvVar], -- Given evidence variables
721 -- (order does not matter)
723 ic_wanted :: WantedConstraints, -- Wanted constraints
725 ic_binds :: EvBindsVar, -- Points to the place to fill in the
726 -- abstraction and bindings
730 evVarsToWanteds :: WantedLoc -> [EvVar] -> WantedConstraints
731 evVarsToWanteds loc evs = listToBag [WcEvVar (WantedEvVar ev loc) | ev <- evs]
733 wantedEvVarLoc :: WantedEvVar -> WantedLoc
734 wantedEvVarLoc (WantedEvVar _ loc) = loc
736 wantedEvVarToVar :: WantedEvVar -> EvVar
737 wantedEvVarToVar (WantedEvVar ev _) = ev
739 wantedEvVarPred :: WantedEvVar -> PredType
740 wantedEvVarPred (WantedEvVar ev _) = evVarPred ev
742 splitWanteds :: WantedConstraints -> (Bag WantedEvVar, Bag Implication)
743 splitWanteds wanted = partitionBagWith pick wanted
745 pick (WcEvVar v) = Left v
746 pick (WcImplic i) = Right i
749 Note [Skolems in an implication]
750 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
751 The skolems in an implication are not there to perform a skolem escape
752 check. That happens because all the environment variables are in the
753 untouchables, and therefore cannot be unified with anything at all,
754 let alone the skolems.
756 Instead, ic_skols is used only when considering floating a constraint
757 outside the implication in TcSimplify.floatEqualities or
758 TcSimplify.approximateImplications
760 Note [Scoped pattern variables]
761 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
762 data T where K :: forall a,b. a -> b -> T
764 ...(case x of K (p::c) (q::d) -> ...)...
766 We create fresh MetaTvs for c,d, and later check that they are
767 bound bijectively to the skolems we created for a,b. So the
768 implication constraint looks like
769 ic_skols = {a',b'} -- Skolem tvs created from a,b
770 ic_scoped = {c',d'} -- Meta tvs created from c,d
773 emptyWanteds :: WantedConstraints
774 emptyWanteds = emptyBag
776 andWanteds :: WantedConstraints -> WantedConstraints -> WantedConstraints
777 andWanteds = unionBags
779 extendWanteds :: WantedConstraints -> WantedConstraint -> WantedConstraints
780 extendWanteds = snocBag
784 pprEvVars :: [EvVar] -> SDoc -- Print with their types
785 pprEvVars ev_vars = vcat (map pprEvVarWithType ev_vars)
787 pprEvVarTheta :: [EvVar] -> SDoc
788 pprEvVarTheta ev_vars = pprTheta (map evVarPred ev_vars)
790 pprEvVarWithType :: EvVar -> SDoc
791 pprEvVarWithType v = ppr v <+> dcolon <+> pprPred (evVarPred v)
793 pprWantedsWithLocs :: Bag WantedConstraint -> SDoc
794 pprWantedsWithLocs = foldrBag (($$) . pprWantedWithLoc) empty
796 pprWantedWithLoc :: WantedConstraint -> SDoc
797 pprWantedWithLoc (WcImplic i) = ppr i
798 pprWantedWithLoc (WcEvVar v) = pprWantedEvVarWithLoc v
800 instance Outputable WantedConstraint where
801 ppr (WcEvVar v) = ppr v
802 ppr (WcImplic i) = ppr i
804 -- Adding -ferror-spans makes the output more voluminous
805 instance Outputable WantedEvVar where
806 ppr wev | opt_ErrorSpans = pprWantedEvVarWithLoc wev
807 | otherwise = pprWantedEvVar wev
809 pprWantedEvVarWithLoc, pprWantedEvVar :: WantedEvVar -> SDoc
810 pprWantedEvVarWithLoc (WantedEvVar v loc) = hang (pprEvVarWithType v)
812 pprWantedEvVar (WantedEvVar v _) = pprEvVarWithType v
814 instance Outputable Implication where
815 ppr (Implic { ic_env_tvs = env_tvs, ic_skols = skols, ic_given = given
816 , ic_wanted = wanted, ic_binds = binds, ic_loc = loc })
817 = ptext (sLit "Implic") <+> braces
818 (sep [ ptext (sLit "Untouchables = ") <+> ppr env_tvs
819 , ptext (sLit "Skolems = ") <+> ppr skols
820 , ptext (sLit "Given = ") <+> pprEvVars given
821 , ptext (sLit "Wanted = ") <+> ppr wanted
822 , ptext (sLit "Binds = ") <+> ppr binds
823 , pprSkolInfo (ctLocOrigin loc)
824 , ppr (ctLocSpan loc) ])
827 %************************************************************************
831 %************************************************************************
833 The 'CtLoc' and 'CtOrigin' types gives information about where a
834 *wanted constraint* came from. This is important for decent error
835 message reporting because dictionaries don't appear in the original
836 source code. Doubtless this type will evolve...
839 -------------------------------------------
840 data CtLoc orig = CtLoc orig SrcSpan [ErrCtxt]
842 ctLocSpan :: CtLoc o -> SrcSpan
843 ctLocSpan (CtLoc _ s _) = s
845 ctLocOrigin :: CtLoc o -> o
846 ctLocOrigin (CtLoc o _ _) = o
848 setCtLocOrigin :: CtLoc o -> o' -> CtLoc o'
849 setCtLocOrigin (CtLoc _ s c) o = CtLoc o s c
851 pprArising :: CtLoc CtOrigin -> SDoc
852 pprArising loc = case ctLocOrigin loc of
853 TypeEqOrigin -> empty
854 _ -> text "arising from" <+> ppr (ctLocOrigin loc)
856 pprArisingAt :: CtLoc CtOrigin -> SDoc
857 pprArisingAt loc = sep [pprArising loc, text "at" <+> ppr (ctLocSpan loc)]
859 -------------------------------------------
860 -- CtOrigin gives the origin of *wanted* constraints
862 = OccurrenceOf Name -- Occurrence of an overloaded identifier
863 | AppOrigin -- An application of some kind
865 | SpecPragOrigin Name -- Specialisation pragma for identifier
869 | IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter
871 | LiteralOrigin (HsOverLit Name) -- Occurrence of a literal
872 | NegateOrigin -- Occurrence of syntactic negation
874 | ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc
875 | PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:]
877 | TupleOrigin -- (..,..)
878 | ExprSigOrigin -- e :: ty
879 | PatSigOrigin -- p :: ty
880 | PatOrigin -- Instantiating a polytyped pattern at a constructor
884 | ScOrigin -- Typechecking superclasses of an instance declaration
885 | DerivOrigin -- Typechecking deriving
886 | StandAloneDerivOrigin -- Typechecking stand-alone deriving
887 | DefaultOrigin -- Typechecking a default decl
888 | DoOrigin -- Arising from a do expression
889 | ProcOrigin -- Arising from a proc expression
890 | AnnOrigin -- An annotation
894 { uo_actual :: TcType
895 , uo_expected :: TcType }
897 instance Outputable CtOrigin where
900 pprO :: CtOrigin -> SDoc
901 pprO (OccurrenceOf name) = hsep [ptext (sLit "a use of"), quotes (ppr name)]
902 pprO AppOrigin = ptext (sLit "an application")
903 pprO (SpecPragOrigin name) = hsep [ptext (sLit "a specialisation pragma for"), quotes (ppr name)]
904 pprO (IPOccOrigin name) = hsep [ptext (sLit "a use of implicit parameter"), quotes (ppr name)]
905 pprO RecordUpdOrigin = ptext (sLit "a record update")
906 pprO ExprSigOrigin = ptext (sLit "an expression type signature")
907 pprO PatSigOrigin = ptext (sLit "a pattern type signature")
908 pprO PatOrigin = ptext (sLit "a pattern")
909 pprO ViewPatOrigin = ptext (sLit "a view pattern")
910 pprO (LiteralOrigin lit) = hsep [ptext (sLit "the literal"), quotes (ppr lit)]
911 pprO (ArithSeqOrigin seq) = hsep [ptext (sLit "the arithmetic sequence"), quotes (ppr seq)]
912 pprO (PArrSeqOrigin seq) = hsep [ptext (sLit "the parallel array sequence"), quotes (ppr seq)]
913 pprO SectionOrigin = ptext (sLit "an operator section")
914 pprO TupleOrigin = ptext (sLit "a tuple")
915 pprO NegateOrigin = ptext (sLit "a use of syntactic negation")
916 pprO ScOrigin = ptext (sLit "the superclasses of an instance declaration")
917 pprO DerivOrigin = ptext (sLit "the 'deriving' clause of a data type declaration")
918 pprO StandAloneDerivOrigin = ptext (sLit "a 'deriving' declaration")
919 pprO DefaultOrigin = ptext (sLit "a 'default' declaration")
920 pprO DoOrigin = ptext (sLit "a do statement")
921 pprO ProcOrigin = ptext (sLit "a proc expression")
922 pprO TypeEqOrigin = ptext (sLit "an equality")
923 pprO AnnOrigin = ptext (sLit "an annotation")
925 instance Outputable EqOrigin where
926 ppr (UnifyOrigin t1 t2) = ppr t1 <+> char '~' <+> ppr t2