import Id ( Id(..), GenId, idType, mkUserLocal )
import TcHsSyn ( TcIdBndr(..), TcIdOcc(..) )
-import TcKind ( TcKind, newKindVars, tcKindToKind, kindToTcKind )
-import TcType ( TcType(..), TcMaybe, TcTyVar(..), TcTyVarSet(..), newTyVarTys, zonkTcTyVars )
-import TyVar ( mkTyVar, getTyVarKind, unionTyVarSets, emptyTyVarSet )
+import TcKind ( TcKind, newKindVars, tcDefaultKind, kindToTcKind )
+import TcType ( TcType(..), TcMaybe, TcTyVar(..), TcTyVarSet(..),
+ newTyVarTys, tcInstTyVars, tcInstType, zonkTcTyVars
+ )
+import TyVar ( mkTyVar, tyVarKind, unionTyVarSets, emptyTyVarSet )
import Type ( tyVarsOfTypes )
-import TyCon ( TyCon, Arity(..), getTyConKind, getSynTyConArity )
-import Class ( Class(..), GenClass, getClassSig )
+import TyCon ( TyCon, Arity(..), tyConKind, synTyConArity )
+import Class ( Class(..), GenClass, classSig )
import TcMonad
-import Name ( Name(..), getNameShortName )
+import Name ( getOccName, getSrcLoc, Name{-instance NamedThing-} )
import PprStyle
import Pretty
-import Unique ( Unique )
-import UniqFM
-import Util ( zipWithEqual, zipWith3Equal, zipLazy, panic )
+import RnHsSyn ( RnName(..) )
+import Type ( splitForAllTy )
+import Unique ( pprUnique10, pprUnique{-ToDo:rm-} )
+import UniqFM
+import Util ( zipWithEqual, zipWith3Equal, zipLazy, panic, pprPanic, pprTrace{-ToDo:rm-} )
\end{code}
Data type declarations
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
tcTyVarScopeGivenKinds
- :: [Name] -- Names of some type variables
+ :: [Name] -- Names of some type variables
-> [TcKind s]
- -> ([TyVar] -> TcM s a) -- Thing to type check in their scope
- -> TcM s a -- Result
+ -> ([TyVar] -> TcM s a) -- Thing to type check in their scope
+ -> TcM s a -- Result
tcTyVarScopeGivenKinds names kinds thing_inside
= fixTc (\ ~(rec_tyvars, _) ->
(thing_inside rec_tyvars) `thenTc` \ result ->
-- Get the tyvar's Kinds from their TcKinds
- mapNF_Tc tcKindToKind kinds `thenNF_Tc` \ kinds' ->
+ mapNF_Tc tcDefaultKind kinds `thenNF_Tc` \ kinds' ->
-- Construct the real TyVars
let
tyvars = zipWithEqual mk_tyvar names kinds'
- mk_tyvar name kind = mkTyVar (getNameShortName name) (getItsUnique name) kind
+ mk_tyvar name kind = mkTyVar name (uniqueOf name) kind
in
returnTc (tyvars, result)
) `thenTc` \ (_,result) ->
that the knot-tied TyVars, TyCons and Classes aren't looked at too early.
\begin{code}
-tcExtendTyConEnv :: [(Name,Maybe Arity)] -> [TyCon] -> TcM s r -> TcM s r
+tcExtendTyConEnv :: [(RnName,Maybe Arity)] -> [TyCon] -> TcM s r -> TcM s r
+
tcExtendTyConEnv names_w_arities tycons scope
= newKindVars (length names_w_arities) `thenNF_Tc` \ kinds ->
tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
(kinds `zipLazy` tycons)
]
in
- tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope
+ tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope `thenTc` \ result ->
+ mapNF_Tc tcDefaultKind kinds `thenNF_Tc_`
+ returnTc result
+
-tcExtendClassEnv :: [Name] -> [Class] -> TcM s r -> TcM s r
+tcExtendClassEnv :: [RnName] -> [Class] -> TcM s r -> TcM s r
tcExtendClassEnv names classes scope
= newKindVars (length names) `thenNF_Tc` \ kinds ->
tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
let
ce' = addListToUFM ce (names `zip` (kinds `zipLazy` classes))
in
- tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope
+ tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope `thenTc` \ result ->
+ mapNF_Tc tcDefaultKind kinds `thenNF_Tc_`
+ returnTc result
\end{code}
\begin{code}
tcLookupTyVar name
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM tve (panic "tcLookupTyVar") name)
+ returnNF_Tc (lookupWithDefaultUFM tve (pprPanic "tcLookupTyVar:" (ppr PprShowAll name)) name)
tcLookupTyCon (WiredInTyCon tc) -- wired in tycons
- = returnNF_Tc (kindToTcKind (getTyConKind tc), getSynTyConArity tc, tc)
+ = returnNF_Tc (kindToTcKind (tyConKind tc), synTyConArity tc, tc)
tcLookupTyCon name
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM tce (panic "tcLookupTyCon") name)
+ returnNF_Tc (lookupWithDefaultUFM tce (pprPanic "tcLookupTyCon:" (ppr PprShowAll name)) name)
tcLookupTyConByKey uniq
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
let
- (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce (panic "tcLookupTyCon") uniq
+ (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce
+ (pprPanic "tcLookupTyCon:" (pprUnique10 uniq))
+ uniq
in
returnNF_Tc tycon
tcLookupClass name
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM ce (panic "tcLookupClass") name)
+-- pprTrace "tcLookupClass:" (ppCat [ppStr "Uniq:", pprUnique10 (uniqueOf name), ppStr "; avail:", ppCat (map (pprUnique10 . fst) (ufmToList ce))]) $
+-- pprTrace "tcLookupClass:" (ppCat [ppStr "Uniq:", pprUnique (uniqueOf name), ppStr "; avail:", ppCat (map (pprUnique . fst) (ufmToList ce))]) $
+ returnNF_Tc (lookupWithDefaultUFM ce (pprPanic "tcLookupClass:" (ppr PprShowAll name)) name)
tcLookupClassByKey uniq
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
let
- (kind, clas) = lookupWithDefaultUFM_Directly ce (panic "tcLookupClas") uniq
+ (kind, clas) = lookupWithDefaultUFM_Directly ce
+ (pprPanic "tcLookupClassByKey:" (pprUnique10 uniq))
+ uniq
in
returnNF_Tc clas
\end{code}
tcExtendGlobalValEnv ids scope
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
let
- gve' = addListToUFM_Directly gve [(getItsUnique id, id) | id <- ids]
+ gve' = addListToUFM_Directly gve [(uniqueOf id, id) | id <- ids]
in
tcSetEnv (TcEnv tve tce ce gve' lve gtvs) scope
\end{code}
\begin{code}
-tcLookupLocalValue :: Name -> NF_TcM s (Maybe (TcIdBndr s))
+tcLookupLocalValue :: RnName -> NF_TcM s (Maybe (TcIdBndr s))
tcLookupLocalValue name
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
returnNF_Tc (lookupUFM lve name)
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
returnNF_Tc (lookupUFM_Directly lve uniq)
-tcLookupLocalValueOK :: String -> Name -> NF_TcM s (TcIdBndr s)
+tcLookupLocalValueOK :: String -> RnName -> NF_TcM s (TcIdBndr s)
tcLookupLocalValueOK err name
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
returnNF_Tc (lookupWithDefaultUFM lve (panic err) name)
-tcLookupGlobalValue :: Name -> NF_TcM s Id
+tcLookupGlobalValue :: RnName -> NF_TcM s Id
-tcLookupGlobalValue (WiredInVal id) -- wired in ids
+tcLookupGlobalValue (WiredInId id) -- wired in ids
= returnNF_Tc id
tcLookupGlobalValue name
returnNF_Tc (lookupWithDefaultUFM gve def name)
where
#ifdef DEBUG
- def = panic ("tcLookupGlobalValue:" ++ ppShow 1000 (ppr PprDebug name))
+ def = pprPanic "tcLookupGlobalValue:" (ppr PprDebug name)
#else
def = panic "tcLookupGlobalValue"
#endif
-
tcLookupGlobalValueByKey :: Unique -> NF_TcM s Id
tcLookupGlobalValueByKey uniq
= tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
returnNF_Tc (lookupWithDefaultUFM_Directly gve def uniq)
where
#ifdef DEBUG
- def = panic ("tcLookupGlobalValueByKey:" ++ ppShow 1000 (ppr PprDebug uniq))
+ def = pprPanic "tcLookupGlobalValueByKey:" (pprUnique10 uniq)
#else
def = panic "tcLookupGlobalValueByKey"
#endif
~~~~~~~~~~~~~~~~~~~~
\begin{code}
-newMonoIds :: [Name] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a
+newMonoIds :: [RnName] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a
+
newMonoIds names kind m
= newTyVarTys no_of_names kind `thenNF_Tc` \ tys ->
tcGetUniques no_of_names `thenNF_Tc` \ uniqs ->
let
- new_ids = zipWith3Equal mk_id names uniqs tys
- mk_id name uniq ty = mkUserLocal (getOccurrenceName name) uniq ty
- (getSrcLoc name)
+ new_ids = zipWith3Equal mk_id names uniqs tys
+
+ mk_id name uniq ty
+ = let
+ name_str = case (getOccName name) of { Unqual n -> n }
+ in
+ mkUserLocal name_str uniq ty (getSrcLoc name)
in
tcExtendLocalValEnv names new_ids (m new_ids)
where
projects / ghc-hetmet.git / blobdiff