import Type
import Coercion
import TcType
-import TcGadt
import InstEnv
import FamInstEnv
import IOEnv
import Var
import VarEnv
import Module
-import UniqFM
+import LazyUniqFM
import SrcLoc
import VarSet
import ErrUtils
import Outputable
import ListSetOps
import FiniteMap
+import FastString
import Data.Maybe
import Data.List
tcl_ctxt :: ErrCtxt, -- Error context
tcl_errs :: TcRef Messages, -- Place to accumulate errors
- tcl_th_ctxt :: ThStage, -- Template Haskell context
- tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context
+ tcl_th_ctxt :: ThStage, -- Template Haskell context
+ tcl_arrow_ctxt :: ArrowCtxt, -- Arrow-notation context
tcl_rdr :: LocalRdrEnv, -- Local name envt
-- Maintained during renaming, of course, but also during
-- 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
pprTcTyThingCategory :: TcTyThing -> SDoc
pprTcTyThingCategory (AGlobal thing) = pprTyThingCategory thing
-pprTcTyThingCategory (ATyVar {}) = ptext SLIT("Type variable")
-pprTcTyThingCategory (ATcId {}) = ptext SLIT("Local identifier")
-pprTcTyThingCategory (AThing {}) = ptext SLIT("Kinded thing")
+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")
+ 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}
| ImportBySystem -- Non user import.
instance Outputable WhereFrom where
- ppr (ImportByUser is_boot) | is_boot = ptext SLIT("{- SOURCE -}")
+ ppr (ImportByUser is_boot) | is_boot = ptext (sLit "{- SOURCE -}")
| otherwise = empty
- ppr ImportBySystem = ptext SLIT("{- SYSTEM -}")
+ ppr ImportBySystem = ptext (sLit "{- SYSTEM -}")
\end{code}
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'
+represent implication constraints 'forall tvs. given => wanted'
and equality constraints 'co :: ty1 ~ ty2'.
NB: Equalities occur in two flavours:
}
| ImplicInst { -- An implication constraint
- -- forall tvs. (reft, given) => wanted
+ -- forall tvs. given => wanted
tci_name :: Name,
tci_tyvars :: [TcTyVar], -- Quantified type variables
- -- 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
}
- -- NB: the tci_given are not necessarily rigid,
- -- although they will be if the tci_reft is non-trivial
- -- NB: the tci_reft is already applied to tci_given and tci_wanted
+ -- NB: the tci_given are not necessarily rigid
| Method {
tci_id :: TcId, -- The Id for the Inst
instLocOrigin (InstLoc o _ _) = o
pprInstArising :: Inst -> SDoc
-pprInstArising loc = ptext SLIT("arising from") <+> pprInstLoc (tci_loc loc)
+pprInstArising loc = ptext (sLit "arising from") <+> pprInstLoc (tci_loc loc)
pprInstLoc :: InstLoc -> SDoc
pprInstLoc (InstLoc orig span _) = sep [ppr orig, text "at" <+> ppr span]
-- 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
| EqOrigin -- A type equality
instance Outputable InstOrigin where
- ppr (OccurrenceOf name) = hsep [ptext SLIT("a use of"), 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 (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 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 DefaultOrigin = ptext SLIT("a 'default' declaration")
- ppr DoOrigin = ptext SLIT("a do statement")
- ppr ProcOrigin = ptext SLIT("a proc expression")
+ 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 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 DefaultOrigin = ptext (sLit "a 'default' declaration")
+ ppr DoOrigin = ptext (sLit "a do statement")
+ ppr ProcOrigin = ptext (sLit "a proc expression")
ppr (ImplicOrigin doc) = doc
ppr (SigOrigin info) = pprSkolInfo info
- ppr EqOrigin = ptext SLIT("a type equality")
-
+ ppr EqOrigin = ptext (sLit "a type equality")
\end{code}
projects / ghc-hetmet.git / blobdiff