-%
+
% (c) The University of Glasgow 2006
% (c) The GRASP Project, Glasgow University, 1992-2002
%
\begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module TcRnTypes(
TcRnIf, TcRn, TcM, RnM, IfM, IfL, IfG, -- The monad is opaque outside this module
TcRef,
WhereFrom(..), mkModDeps,
-- Typechecker types
- TcTyThing(..), pprTcTyThingCategory,
+ TcTyThing(..), pprTcTyThingCategory, RefinementVisibility(..),
-- Template Haskell
ThStage(..), topStage, topSpliceStage,
plusLIEs, mkLIE, isEmptyLIE, lieToList, listToLIE,
-- Misc other types
- TcId, TcIdSet, TcDictBinds
+ TcId, TcIdSet, TcDictBinds,
+
) where
#include "HsVersions.h"
import HscTypes
import Packages
import Type
+import Coercion
import TcType
import TcGadt
import InstEnv
import Bag
import Outputable
import ListSetOps
+import FiniteMap
import Data.Maybe
import Data.List
env_gbl :: gbl, -- Info about things defined at the top level
-- of the module being compiled
- env_lcl :: lcl -- Nested stuff; changes as we go into
- -- an expression
+ env_lcl :: lcl -- Nested stuff; changes as we go into
}
-- TcGblEnv describes the top-level of the module at the
-- (Ids defined in this module start in the local envt,
-- though they move to the global envt during zonking)
- tcg_type_env_var :: TcRef TypeEnv,
+ tcg_type_env_var :: TcRef TypeEnv,
-- Used only to initialise the interface-file
-- typechecker in initIfaceTcRn, so that it can see stuff
-- bound in this module when dealing with hi-boot recursions
-- Maintained during renaming, of course, but also during
-- type checking, solely so that when renaming a Template-Haskell
-- splice we have the right environment for the renamer.
- --
- -- Used only for names bound within a value binding (bound by
- -- lambda, case, where, let etc), but *not* for top-level names.
- --
- -- Does *not* include global name envt; may shadow it
- -- Includes both ordinary variables and type variables;
- -- they are kept distinct because tyvar have a different
- -- occurrence contructor (Name.TvOcc)
--
+ -- Does *not* include global name envt; may shadow it
+ -- Includes both ordinary variables and type variables;
+ -- they are kept distinct because tyvar have a different
+ -- occurrence contructor (Name.TvOcc)
-- We still need the unsullied global name env so that
-- we can look up record field names
-- Incremented when going inside a bracket,
-- decremented when going inside a splice
-- NB: ThLevel is one greater than the 'n' in Fig 2 of the
- -- original "Template meta-programmign for Haskell" paper
+ -- original "Template meta-programming for Haskell" paper
impLevel, topLevel :: ThLevel
topLevel = 1 -- Things defined at top level of this module
| ATcId { -- Ids defined in this module; may not be fully zonked
tct_id :: TcId,
- tct_co :: Maybe HsWrapper, -- Nothing <=> Do not apply a GADT type refinement
+ tct_co :: RefinementVisibility, -- Previously: Maybe HsWrapper
+ -- Nothing <=> Do not apply a GADT type refinement
-- I am wobbly, or have no free
-- type variables
-- Just co <=> Apply any type refinement to me,
| AThing TcKind -- Used temporarily, during kind checking, for the
-- tycons and clases in this recursive group
+data RefinementVisibility
+ = Unrefineable -- Do not apply a GADT refinement
+ -- I have no free variables
+
+ | Rigid HsWrapper -- Apply any refinement to me
+ -- and record it in the coercion
+
+ | Wobbly -- Do not apply a GADT refinement
+ -- I am wobbly
+
+ | WobblyInvisible -- Wobbly type, not available inside current
+ -- GADT refinement
+
instance Outputable TcTyThing where -- Debugging only
- ppr (AGlobal g) = ppr g
+ ppr (AGlobal g) = pprTyThing g
ppr elt@(ATcId {}) = text "Identifier" <>
ifPprDebug (brackets (ppr (tct_id elt) <> dcolon <> ppr (tct_type elt) <> comma
<+> ppr (tct_level elt) <+> ppr (tct_co elt)))
pprTcTyThingCategory (ATyVar {}) = ptext SLIT("Type variable")
pprTcTyThingCategory (ATcId {}) = ptext SLIT("Local identifier")
pprTcTyThingCategory (AThing {}) = ptext SLIT("Kinded thing")
+
+instance Outputable RefinementVisibility where
+ ppr Unrefineable = ptext SLIT("unrefineable")
+ ppr (Rigid co) = ptext SLIT("rigid") <+> ppr co
+ ppr Wobbly = ptext SLIT("wobbly")
+ ppr WobblyInvisible = ptext SLIT("wobbly-invisible")
+
\end{code}
\begin{code}
\begin{code}
data ImportAvails
= ImportAvails {
- imp_mods :: ModuleEnv (Module, Bool, SrcSpan),
+ imp_mods :: ModuleEnv (Module, [(ModuleName, Bool, SrcSpan)]),
-- Domain is all directly-imported modules
+ -- The ModuleName is what the module was imported as, e.g. in
+ -- import Foo as Bar
+ -- it is Bar.
-- Bool means:
-- True => import was "import Foo ()"
-- False => import was some other form
(ImportAvails { imp_mods = mods2,
imp_dep_mods = dmods2, imp_dep_pkgs = dpkgs2,
imp_orphs = orphs2, imp_finsts = finsts2 })
- = ImportAvails { imp_mods = mods1 `plusModuleEnv` mods2,
+ = ImportAvails { imp_mods = plusModuleEnv_C plus_mod mods1 mods2,
imp_dep_mods = plusUFM_C plus_mod_dep dmods1 dmods2,
imp_dep_pkgs = dpkgs1 `unionLists` dpkgs2,
imp_orphs = orphs1 `unionLists` orphs2,
imp_finsts = finsts1 `unionLists` finsts2 }
where
+ plus_mod (m1, xs1) (_, xs2) = (m1, xs1 ++ xs2)
plus_mod_dep (m1, boot1) (m2, boot2)
= WARN( not (m1 == m2), (ppr m1 <+> ppr m2) $$ (ppr boot1 <+> ppr boot2) )
-- Check mod-names match
Method 34 doubleId [Int] origin
+In addition to the basic Haskell variants of 'Inst's, they can now also
+represent implication constraints 'forall tvs. (reft, given) => wanted'
+and equality constraints 'co :: ty1 ~ ty2'.
+
+NB: Equalities occur in two flavours:
+
+ (1) Dict {tci_pred = EqPred ty1 ty2}
+ (2) EqInst {tci_left = ty1, tci_right = ty2, tci_co = coe}
+
+The former arises from equalities in contexts, whereas the latter is used
+whenever the type checker introduces an equality (e.g., during deferring
+unification).
+
+I am not convinced that this duplication is necessary or useful! -=chak
+
\begin{code}
data Inst
= Dict {
-- Includes coercion variables
-- mentioned in tci_reft
tci_reft :: Refinement,
- tci_given :: [Inst], -- Only Dicts
+ tci_given :: [Inst], -- Only Dicts and EqInsts
-- (no Methods, LitInsts, ImplicInsts)
- tci_wanted :: [Inst], -- Only Dicts and ImplicInsts
+ tci_wanted :: [Inst], -- Only Dicts, EqInst, and ImplicInsts
-- (no Methods or LitInsts)
tci_loc :: InstLoc
tci_ty :: TcType, -- The type at which the literal is used
tci_loc :: InstLoc
}
+
+ | EqInst { -- delayed unification of the form
+ -- co :: ty1 ~ ty2
+ tci_left :: TcType, -- ty1 -- both types are...
+ tci_right :: TcType, -- ty2 -- ...free of boxes
+ tci_co :: Either -- co
+ TcTyVar -- - a wanted equation, with a hole, to be
+ -- filled with a witness for the equality;
+ -- for equation arising from deferring
+ -- unification, 'ty1' is the actual and
+ -- 'ty2' the expected type
+ Coercion, -- - a given equation, with a coercion
+ -- witnessing the equality;
+ -- a coercion that originates from a
+ -- signature or a GADT is a CoVar, but
+ -- after normalisation of coercions, they
+ -- can be arbitrary Coercions involving
+ -- constructors and pseudo-constructors
+ -- like sym and trans.
+ tci_loc :: InstLoc,
+
+ tci_name :: Name -- Debugging help only: this makes it easier to
+ -- follow where a constraint is used in a morass
+ -- of trace messages! Unlike other Insts, it has
+ -- no semantic significance whatsoever.
+ }
\end{code}
@Insts@ are ordered by their class/type info, rather than by their
cmpInst (ImplicInst {}) (Method {}) = GT
cmpInst (ImplicInst {}) (LitInst {}) = GT
cmpInst i1@(ImplicInst {}) i2@(ImplicInst {}) = tci_name i1 `compare` tci_name i2
+cmpInst (ImplicInst {}) other = LT
+
+ -- same for Equality constraints
+cmpInst (EqInst {}) (Dict {}) = GT
+cmpInst (EqInst {}) (Method {}) = GT
+cmpInst (EqInst {}) (LitInst {}) = GT
+cmpInst (EqInst {}) (ImplicInst {}) = GT
+cmpInst i1@(EqInst {}) i2@(EqInst {}) = tci_name i1 `compare` tci_name i2
\end{code}
-- The rest are all occurrences: Insts that are 'wanted'
-------------------------------------------------------
| OccurrenceOf Name -- Occurrence of an overloaded identifier
+ | SpecPragOrigin Name -- Specialisation pragma for identifier
| IPOccOrigin (IPName Name) -- Occurrence of an implicit parameter
| LiteralOrigin (HsOverLit Name) -- Occurrence of a literal
+ | NegateOrigin -- Occurrence of syntactic negation
| ArithSeqOrigin (ArithSeqInfo Name) -- [x..], [x..y] etc
| PArrSeqOrigin (ArithSeqInfo Name) -- [:x..y:] and [:x,y..z:]
+ | TupleOrigin -- (..,..)
| InstSigOrigin -- A dict occurrence arising from instantiating
-- a polymorphic type during a subsumption check
+ | ExprSigOrigin -- e :: ty
| RecordUpdOrigin
+ | ViewPatOrigin
| InstScOrigin -- Typechecking superclasses of an instance declaration
| DerivOrigin -- Typechecking deriving
| StandAloneDerivOrigin -- Typechecking stand-alone deriving
| DoOrigin -- Arising from a do expression
| ProcOrigin -- Arising from a proc expression
| ImplicOrigin SDoc -- An implication constraint
+ | EqOrigin -- A type equality
instance Outputable InstOrigin where
ppr (OccurrenceOf name) = hsep [ptext SLIT("a use of"), quotes (ppr name)]
+ ppr (SpecPragOrigin name) = hsep [ptext SLIT("a specialisation pragma for"), quotes (ppr name)]
ppr (IPOccOrigin name) = hsep [ptext SLIT("a use of implicit parameter"), quotes (ppr name)]
ppr (IPBindOrigin name) = hsep [ptext SLIT("a binding for implicit parameter"), quotes (ppr name)]
ppr RecordUpdOrigin = ptext SLIT("a record update")
+ ppr ExprSigOrigin = ptext SLIT("an expression type signature")
+ ppr ViewPatOrigin = ptext SLIT("a view pattern")
ppr (LiteralOrigin lit) = hsep [ptext SLIT("the literal"), quotes (ppr lit)]
ppr (ArithSeqOrigin seq) = hsep [ptext SLIT("the arithmetic sequence"), quotes (ppr seq)]
ppr (PArrSeqOrigin seq) = hsep [ptext SLIT("the parallel array sequence"), quotes (ppr seq)]
- ppr InstSigOrigin = ptext SLIT("instantiating a type signature")
+ ppr TupleOrigin = ptext SLIT("a tuple")
+ ppr NegateOrigin = ptext SLIT("a use of syntactic negation")
ppr InstScOrigin = ptext SLIT("the superclasses of an instance declaration")
ppr DerivOrigin = ptext SLIT("the 'deriving' clause of a data type declaration")
ppr StandAloneDerivOrigin = ptext SLIT("a 'deriving' declaration")
ppr ProcOrigin = ptext SLIT("a proc expression")
ppr (ImplicOrigin doc) = doc
ppr (SigOrigin info) = pprSkolInfo info
+ ppr EqOrigin = ptext SLIT("a type equality")
\end{code}