\begin{code}
module TcEnv(
- TcIdOcc(..), TcIdBndr, TcIdSet, tcIdType, tcIdTyVars, tcInstId,
+ TcId, TcIdSet, tcInstId,
tcLookupDataCon,
- TcEnv, GlobalValueEnv,
+ TcEnv, ValueEnv, TcTyThing(..),
- initEnv, getEnv_TyCons, getEnv_Classes,
+ initEnv, getEnvTyCons, getEnvClasses, getAllEnvTyCons,
- tcExtendTyVarEnv, tcLookupTyVar, tcLookupTyVarBndrs,
+ tcExtendUVarEnv, tcLookupUVar,
- tcExtendTyConEnv, tcLookupTyCon, tcLookupTyConByKey,
- tcExtendClassEnv, tcLookupClass, tcLookupClassByKey,
- tcGetTyConsAndClasses,
+ tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars,
- tcExtendGlobalValEnv, tcExtendLocalValEnv, tcExtendEnvWithPat,
- tcGetGlobalValEnv, tcSetGlobalValEnv, lookupGlobalByKey,
- tcLookupLocalValue, tcLookupLocalValueOK, tcLookupLocalValueByKey,
- tcLookupGlobalValue, tcLookupGlobalValueByKey, tcLookupGlobalValueMaybe,
- tcAddImportedIdInfo, tcExplicitLookupGlobal,
- tcLookupGlobalValueByKeyMaybe,
+ tcLookupTy,
+ tcLookupTyCon, tcLookupTyConByKey,
+ tcLookupClass, tcLookupClassByKey, tcLookupClassByKey_maybe,
- newLocalIds, newLocalId, newSpecPragmaId,
- tcGetGlobalTyVars, tcExtendGlobalTyVars,
+ tcExtendGlobalValEnv, tcExtendLocalValEnv,
+ tcGetValueEnv, tcSetValueEnv,
+ tcAddImportedIdInfo,
+
+ tcLookupValue, tcLookupValueMaybe,
+ tcLookupValueByKey, tcLookupValueByKeyMaybe,
+ explicitLookupValueByKey, explicitLookupValue,
+ valueEnvIds,
- tidyType, tidyTypes, tidyTyVar,
+ newLocalId, newSpecPragmaId,
+ tcGetGlobalTyVars, tcExtendGlobalTyVars,
badCon, badPrimOp
) where
#include "HsVersions.h"
-import HsTypes ( getTyVarName )
+import HsTypes ( HsTyVar, getTyVarName )
import Id ( mkUserLocal, isDataConId_maybe )
import MkId ( mkSpecPragmaId )
-import Var ( TyVar, Id, GenId, setVarName,
- idType, setIdInfo, idInfo
+import Var ( TyVar, Id, setVarName,
+ idType, lazySetIdInfo, idInfo, tyVarKind, UVar,
)
-import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType, TcBox,
+import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType,
tcInstTyVars, zonkTcTyVars,
TcKind, kindToTcKind
)
import VarEnv
import VarSet
-import Type ( Kind,
- tyVarsOfType, tyVarsOfTypes, mkTyVarTy, substTy,
- splitForAllTys, splitRhoTy, splitFunTys, substFlexiTy,
+import Type ( Kind, superKind,
+ tyVarsOfType, tyVarsOfTypes, mkTyVarTy,
+ splitForAllTys, splitRhoTy, splitFunTys,
splitAlgTyConApp_maybe, getTyVar
)
+import Subst ( substTy )
+import UsageSPUtils ( unannotTy )
import DataCon ( DataCon )
import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon )
-import Class ( Class )
+import Class ( Class, classTyCon )
import TcMonad
import BasicTypes ( Arity )
-import IdInfo ( noIdInfo )
-import Name ( Name, OccName(..), nameOccName, occNameString, mkLocalName,
+import IdInfo ( vanillaIdInfo )
+import Name ( Name, OccName, nameOccName, getSrcLoc,
maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined,
- isSysLocalName,
NamedThing(..)
)
import Unique ( pprUnique10, Unique, Uniquable(..) )
import Unique ( Uniquable(..) )
import Util ( zipEqual, zipWith3Equal, mapAccumL )
import Bag ( bagToList )
-import Maybes ( maybeToBool )
+import Maybes ( maybeToBool, catMaybes )
+import SrcLoc ( SrcLoc )
+import FastString ( FastString )
import Outputable
\end{code}
%************************************************************************
%* *
-\subsection{TcId, TcIdOcc}
+\subsection{TcId}
%* *
%************************************************************************
\begin{code}
-type TcIdBndr s = GenId (TcBox s) -- Binders are all TcTypes
-data TcIdOcc s = TcId (TcIdBndr s) -- Bindees may be either
- | RealId Id
-
-type TcIdSet s = GenIdSet (TcBox s)
-
-instance Eq (TcIdOcc s) where
- (TcId id1) == (TcId id2) = id1 == id2
- (RealId id1) == (RealId id2) = id1 == id2
- _ == _ = False
-
-instance Ord (TcIdOcc s) where
- (TcId id1) `compare` (TcId id2) = id1 `compare` id2
- (RealId id1) `compare` (RealId id2) = id1 `compare` id2
- (TcId _) `compare` (RealId _) = LT
- (RealId _) `compare` (TcId _) = GT
-
-instance Outputable (TcIdOcc s) where
- ppr (TcId id) = ppr id
- ppr (RealId id) = ppr id
+type TcId = Id -- Type may be a TcType
+type TcIdSet = IdSet
-instance NamedThing (TcIdOcc s) where
- getName (TcId id) = getName id
- getName (RealId id) = getName id
-
-
-tcIdType :: TcIdOcc s -> TcType s
-tcIdType (TcId id) = idType id
-tcIdType (RealId id) = pprPanic "tcIdType:" (ppr id)
-
-tcIdTyVars (TcId id) = tyVarsOfType (idType id)
-tcIdTyVars (RealId _) = emptyVarSet -- Top level Ids have no free type variables
-
-
-tcLookupDataCon :: Name -> TcM s (DataCon, [TcType s], TcType s)
+tcLookupDataCon :: Name -> TcM s (DataCon, [TcType], TcType)
tcLookupDataCon con_name
- = tcLookupGlobalValue con_name `thenNF_Tc` \ con_id ->
+ = tcLookupValue con_name `thenNF_Tc` \ con_id ->
case isDataConId_maybe con_id of {
Nothing -> failWithTc (badCon con_id);
Just data_con ->
-- A useful function that takes an occurrence of a global thing
-- and instantiates its type with fresh type variables
tcInstId :: Id
- -> NF_TcM s ([TcTyVar s], -- It's instantiated type
- TcThetaType s, --
- TcType s) --
-
+ -> NF_TcM s ([TcTyVar], -- It's instantiated type
+ TcThetaType, --
+ TcType) --
tcInstId id
= let
- (tyvars, rho) = splitForAllTys (idType id)
+ (tyvars, rho) = splitForAllTys (unannotTy (idType id))
in
tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) ->
let
- rho' = substFlexiTy tenv rho
+ rho' = substTy tenv rho
(theta', tau') = splitRhoTy rho'
in
returnNF_Tc (tyvars', theta', tau')
\end{code}
-tidyTy tidies up a type for printing in an error message.
-
-\begin{code}
-tidyType :: TidyTypeEnv s -> TcType s -> (TidyTypeEnv s, TcType s)
-tidyType env ty
- = (env', substTy subst' ty)
- where
- env'@(_, subst') = foldl go env (varSetElems (tyVarsOfType ty))
- go env tyvar = fst (tidyTyVar env tyvar)
-
-tidyTypes :: TidyTypeEnv s -> [TcType s] -> (TidyTypeEnv s, [TcType s])
-tidyTypes env tys = mapAccumL tidyType env tys
-
-tidyTyVar :: TidyTypeEnv s -> TcTyVar s -> (TidyTypeEnv s, TcTyVar s)
-tidyTyVar (supply,subst) tyvar
- = case lookupVarEnv subst tyvar of
- Just ty -> -- Already substituted
- ((supply,subst), getTyVar "tidyTyVar" ty)
- Nothing -> -- Make a new nice name for it
- ((addToFM supply str next,
- extendVarEnv subst tyvar (mkTyVarTy new_tyvar)),
- new_tyvar)
- where
- tyvar_name = getName tyvar
- is_sys = isSysLocalName tyvar_name
-
- str | is_sys = SLIT("$")
- | otherwise = occNameString (nameOccName tyvar_name)
-
- next = case lookupFM supply str of
- Nothing -> 0
- Just n -> n+1
-
- new_tyvar = mkNewTv str is_sys next tyvar
-
-mkNewTv :: FastString -> Bool -> Int -> TcTyVar s -> TcTyVar s
-mkNewTv str False 0 tv = tv -- Leave first non-sys thing alone
-mkNewTv str is_sys n tv = setVarName tv (mkLocalName (getUnique tv)
- (TvOcc (_PK_ ((_UNPK_ str) ++ show n))))
-\end{code}
+Between the renamer and the first invocation of the UsageSP inference,
+identifiers read from interface files will have usage information in
+their types, whereas other identifiers will not. The unannotTy here
+in @tcInstId@ prevents this information from pointlessly propagating
+further prior to the first usage inference.
%************************************************************************
~~~~~~~~~~~~~~~~~~~~~
\begin{code}
-data TcEnv s = TcEnv
- (TcTyVarEnv s)
- (TyConEnv s)
- (ClassEnv s)
- GlobalValueEnv
- (ValueEnv (TcIdBndr s)) -- Locals
- (TcRef s (TcTyVarSet s)) -- Free type variables of locals
- -- ...why mutable? see notes with tcGetGlobalTyVars
-
-type TcTyVarEnv s = UniqFM (TcKind s, TyVar)
-type TyConEnv s = UniqFM (TcKind s, Maybe Arity, TyCon) -- Arity present for Synonyms only
-type ClassEnv s = UniqFM ([TcKind s], Class) -- The kinds are the kinds of the args
- -- to the class
-type ValueEnv id = UniqFM id
-type GlobalValueEnv = ValueEnv Id -- Globals
-
-initEnv :: TcRef s (TcTyVarSet s) -> TcEnv s
-initEnv mut = TcEnv emptyUFM emptyUFM emptyUFM emptyUFM emptyUFM mut
-
-getEnv_TyCons (TcEnv _ ts _ _ _ _) = [tycon | (_, _, tycon) <- eltsUFM ts]
-getEnv_Classes (TcEnv _ _ cs _ _ _) = [clas | (_, clas) <- eltsUFM cs]
-\end{code}
-
-Type variable env
-~~~~~~~~~~~~~~~~~
-\begin{code}
-tcExtendTyVarEnv :: [Name] -> [(TcKind s, TyVar)] -> TcM s r -> TcM s r
-tcExtendTyVarEnv names kinds_w_types scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- let
- tve' = addListToUFM tve (zipEqual "tcTyVarScope" names kinds_w_types)
- in
- tcSetEnv (TcEnv tve' tce ce gve lve gtvs) scope
+data TcEnv = TcEnv
+ UsageEnv
+ TypeEnv
+ ValueEnv
+ (TcTyVarSet, -- The in-scope TyVars
+ TcRef TcTyVarSet) -- Free type variables of the value env
+ -- ...why mutable? see notes with tcGetGlobalTyVars
+ -- Includes the in-scope tyvars
+
+type NameEnv val = UniqFM val -- Keyed by Names
+
+type UsageEnv = NameEnv UVar
+type TypeEnv = NameEnv (TcKind, Maybe Arity, TcTyThing)
+type ValueEnv = NameEnv Id
+
+valueEnvIds :: ValueEnv -> [Id]
+valueEnvIds ve = eltsUFM ve
+
+data TcTyThing = ATyVar TcTyVar -- Mutable only so that the kind can be mutable
+ -- if the kind is mutable, the tyvar must be so that
+ -- zonking works
+ | ATyCon TyCon
+ | AClass Class
+
+
+initEnv :: TcRef TcTyVarSet -> TcEnv
+initEnv mut = TcEnv emptyUFM emptyUFM emptyUFM (emptyVarSet, mut)
+
+getEnvTyCons (TcEnv _ te _ _) = [tc | (_, _, ATyCon tc) <- eltsUFM te]
+getEnvClasses (TcEnv _ te _ _) = [cl | (_, _, AClass cl) <- eltsUFM te]
+getAllEnvTyCons (TcEnv _ te _ _) = catMaybes (map gettc (eltsUFM te))
+ where
+ gettc (_,_, ATyCon tc) = Just tc
+ gettc (_,_, AClass cl) = Just (classTyCon cl)
+ gettc _ = Nothing
\end{code}
-The Kind, TyVar, Class and TyCon envs
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The UsageEnv
+~~~~~~~~~~~~
-Extending the environments.
+Extending the usage environment.
\begin{code}
-tcExtendTyConEnv :: [(Name, (TcKind s, Maybe Arity, TyCon))] -> TcM s r -> TcM s r
-
-tcExtendTyConEnv bindings scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- let
- tce' = addListToUFM tce bindings
- in
- tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope
-
-
-tcExtendClassEnv :: [(Name, ([TcKind s], Class))] -> TcM s r -> TcM s r
-tcExtendClassEnv bindings scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- let
- ce' = addListToUFM ce bindings
- in
- tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope
+tcExtendUVarEnv :: Name -> UVar -> TcM s r -> TcM s r
+tcExtendUVarEnv uv_name uv scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ tcSetEnv (TcEnv (addToUFM ue uv_name uv) te ve gtvs) scope
\end{code}
-
Looking up in the environments.
\begin{code}
-tcLookupTyVarBndrs tyvar_bndrs -- [HsTyVar name]
- = mapAndUnzipNF_Tc (tcLookupTyVar . getTyVarName) tyvar_bndrs
-
-tcLookupTyVar name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM tve (pprPanic "tcLookupTyVar:" (ppr name)) name)
-
-
-tcLookupTyCon name
- = -- Try for a wired-in tycon
- case maybeWiredInTyConName name of {
- Just tc | isSynTyCon tc -> returnTc (kind, Just (tyConArity tc), tc)
- | otherwise -> returnTc (kind, Nothing, tc)
- where {
- kind = kindToTcKind (tyConKind tc)
- };
-
- Nothing ->
-
- -- Try in the environment
- tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- case lookupUFM tce name of {
- Just stuff -> returnTc stuff;
-
- Nothing ->
-
- -- Could be that he's using a class name as a type constructor
- case lookupUFM ce name of
- Just _ -> failWithTc (classAsTyConErr name)
- Nothing -> pprPanic "tcLookupTyCon:" (ppr name)
- } }
-
-tcLookupTyConByKey uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- let
- (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce
- (pprPanic "tcLookupTyConByKey:" (pprUnique10 uniq))
- uniq
- in
- returnNF_Tc tycon
-
-tcLookupClass name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- case lookupUFM ce name of
- Just stuff -- Common case: it's ok
- -> returnTc stuff
-
- Nothing -- Could be that he's using a type constructor as a class
- | maybeToBool (maybeWiredInTyConName name)
- || maybeToBool (lookupUFM tce name)
- -> failWithTc (tyConAsClassErr name)
-
- | otherwise -- Wierd! Renamer shouldn't let this happen
- -> pprPanic "tcLookupClass" (ppr name)
-
-tcLookupClassByKey uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- let
- (kind, clas) = lookupWithDefaultUFM_Directly ce
- (pprPanic "tcLookupClassByKey:" (pprUnique10 uniq))
- uniq
- in
- returnNF_Tc clas
+tcLookupUVar :: Name -> NF_TcM s UVar
+tcLookupUVar uv_name
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ case lookupUFM ue uv_name of
+ Just uv -> returnNF_Tc uv
+ Nothing -> failWithTc (uvNameOutOfScope uv_name)
+\end{code}
-tcGetTyConsAndClasses :: NF_TcM s ([TyCon], [Class])
-tcGetTyConsAndClasses
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc ([tc | (_, _, tc) <- eltsUFM tce],
- [c | (_, c) <- eltsUFM ce])
-\end{code}
+The TypeEnv
+~~~~~~~~~~~~
+Extending the type environment.
-Extending and consulting the value environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
-tcExtendGlobalValEnv ids scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
+tcExtendTyVarEnv :: [TyVar] -> TcM s r -> TcM s r
+tcExtendTyVarEnv tyvars scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (in_scope_tvs, gtvs)) ->
let
- gve' = addListToUFM_Directly gve [(getUnique id, id) | id <- ids]
+ extend_list = [ (getName tv, (kindToTcKind (tyVarKind tv), Nothing, ATyVar tv))
+ | tv <- tyvars
+ ]
+ te' = addListToUFM te extend_list
+ new_tv_set = mkVarSet tyvars
+ in_scope_tvs' = in_scope_tvs `unionVarSet` new_tv_set
in
- tcSetEnv (TcEnv tve tce ce gve' lve gtvs) scope
-
-tcExtendLocalValEnv names ids scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
+ -- It's important to add the in-scope tyvars to the global tyvar set
+ -- as well. Consider
+ -- f (x::r) = let g y = y::r in ...
+ -- Here, g mustn't be generalised. This is also important during
+ -- class and instance decls, when we mustn't generalise the class tyvars
+ -- when typechecking the methods.
+ tc_extend_gtvs gtvs new_tv_set `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (TcEnv ue te' ve (in_scope_tvs', gtvs')) scope
+
+-- This variant, tcExtendTyVarEnvForMeths, takes *two* bunches of tyvars:
+-- the signature tyvars contain the original names
+-- the instance tyvars are what those names should be mapped to
+-- It's needed when typechecking the method bindings of class and instance decls
+-- It does *not* extend the global tyvars; tcMethodBind does that for itself
+
+tcExtendTyVarEnvForMeths :: [TyVar] -> [TcTyVar] -> TcM s r -> TcM s r
+tcExtendTyVarEnvForMeths sig_tyvars inst_tyvars thing_inside
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
let
- lve' = addListToUFM lve (zipEqual "tcExtendLocalValEnv" names ids)
- extra_global_tyvars = tyVarsOfTypes (map idType ids)
- new_global_tyvars = global_tvs `unionVarSet` extra_global_tyvars
+ te' = addListToUFM te stuff
in
- tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (TcEnv ue te' ve gtvs) thing_inside
+ where
+ stuff = [ (getName sig_tv, (kindToTcKind (tyVarKind inst_tv), Nothing, ATyVar inst_tv))
+ | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars
+ ]
- tcSetEnv (TcEnv tve tce ce gve lve' gtvs') scope
+tcExtendGlobalTyVars extra_global_tvs scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (in_scope,gtvs)) ->
+ tc_extend_gtvs gtvs extra_global_tvs `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (TcEnv ue te ve (in_scope,gtvs')) scope
-tcExtendEnvWithPat names_w_ids scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
+tc_extend_gtvs gtvs extra_global_tvs
+ = tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
let
- names_w_ids_list = bagToList names_w_ids
- lve' = addListToUFM lve names_w_ids_list
- extra_global_tyvars = tyVarsOfTypes (map (idType . snd) names_w_ids_list)
- new_global_tyvars = global_tvs `unionVarSet` extra_global_tyvars
+ new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs
in
- tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' ->
-
- tcSetEnv (TcEnv tve tce ce gve lve' gtvs') scope
+ tcNewMutVar new_global_tyvars
\end{code}
@tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment.
the environment.
\begin{code}
-tcGetGlobalTyVars :: NF_TcM s (TcTyVarSet s)
+tcGetGlobalTyVars :: NF_TcM s TcTyVarSet
tcGetGlobalTyVars
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (_,gtvs)) ->
tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
zonkTcTyVars (varSetElems global_tvs) `thenNF_Tc` \ global_tys' ->
let
tcWriteMutVar gtvs global_tvs' `thenNF_Tc_`
returnNF_Tc global_tvs'
-tcExtendGlobalTyVars extra_global_tvs scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
+tcGetInScopeTyVars :: NF_TcM s [TcTyVar]
+tcGetInScopeTyVars
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (in_scope_tvs, gtvs)) ->
+ returnNF_Tc (varSetElems in_scope_tvs)
+\end{code}
+
+
+Type constructors and classes
+
+\begin{code}
+tcExtendTypeEnv :: [(Name, (TcKind, Maybe Arity, TcTyThing))] -> TcM s r -> TcM s r
+tcExtendTypeEnv bindings scope
+ = ASSERT( null [tv | (_, (_,_,ATyVar tv)) <- bindings] )
+ -- Not for tyvars; use tcExtendTyVarEnv
+ tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
let
- new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs
+ te' = addListToUFM te bindings
in
- tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' ->
- tcSetEnv (TcEnv tve tce ce gve lve gtvs') scope
+ tcSetEnv (TcEnv ue te' ve gtvs) scope
\end{code}
+
+Looking up in the environments.
+
\begin{code}
-tcLookupLocalValue :: Name -> NF_TcM s (Maybe (TcIdBndr s))
-tcLookupLocalValue name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupUFM lve name)
+tcLookupTy :: Name -> NF_TcM s (TcKind, Maybe Arity, TcTyThing)
+tcLookupTy name
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ case lookupUFM te name of {
+ Just thing -> returnNF_Tc thing ;
+ Nothing ->
+
+ case maybeWiredInTyConName name of
+ Just tc -> returnNF_Tc (kindToTcKind (tyConKind tc), maybe_arity, ATyCon tc)
+ where
+ maybe_arity | isSynTyCon tc = Just (tyConArity tc)
+ | otherwise = Nothing
+
+ Nothing -> -- This can happen if an interface-file
+ -- unfolding is screwed up
+ failWithTc (tyNameOutOfScope name)
+ }
+
+tcLookupClass :: Name -> NF_TcM s Class
+tcLookupClass name
+ = tcLookupTy name `thenNF_Tc` \ (_, _, AClass clas) ->
+ returnNF_Tc clas
+
+tcLookupTyCon :: Name -> NF_TcM s TyCon
+tcLookupTyCon name
+ = tcLookupTy name `thenNF_Tc` \ (_, _, ATyCon tycon) ->
+ returnNF_Tc tycon
+
+tcLookupClassByKey :: Unique -> NF_TcM s Class
+tcLookupClassByKey key
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ case lookupUFM_Directly te key of
+ Just (_, _, AClass cl) -> returnNF_Tc cl
+ other -> pprPanic "tcLookupClassByKey:" (pprUnique10 key)
+
+tcLookupClassByKey_maybe :: Unique -> NF_TcM s (Maybe Class)
+tcLookupClassByKey_maybe key
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ case lookupUFM_Directly te key of
+ Just (_, _, AClass cl) -> returnNF_Tc (Just cl)
+ other -> returnNF_Tc Nothing
+
+tcLookupTyConByKey :: Unique -> NF_TcM s TyCon
+tcLookupTyConByKey key
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ case lookupUFM_Directly te key of
+ Just (_, _, ATyCon tc) -> returnNF_Tc tc
+ other -> pprPanic "tcLookupTyConByKey:" (pprUnique10 key)
+\end{code}
+
+
-tcLookupLocalValueByKey :: Unique -> NF_TcM s (Maybe (TcIdBndr s))
-tcLookupLocalValueByKey uniq
- = 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 err name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM lve (panic err) name)
+%************************************************************************
+%* *
+\subsection{The value environment}
+%* *
+%************************************************************************
+\begin{code}
+tcExtendGlobalValEnv :: [Id] -> TcM s a -> TcM s a
+tcExtendGlobalValEnv ids scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ let
+ ve' = addListToUFM_Directly ve [(getUnique id, id) | id <- ids]
+ in
+ tcSetEnv (TcEnv ue te ve' gtvs) scope
-tcLookupGlobalValue :: Name -> NF_TcM s Id
-tcLookupGlobalValue name
+tcExtendLocalValEnv :: [(Name,TcId)] -> TcM s a -> TcM s a
+tcExtendLocalValEnv names_w_ids scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (in_scope_tvs,gtvs)) ->
+ tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
+ let
+ ve' = addListToUFM ve names_w_ids
+ extra_global_tyvars = tyVarsOfTypes (map (idType . snd) names_w_ids)
+ in
+ tc_extend_gtvs gtvs extra_global_tyvars `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (TcEnv ue te ve' (in_scope_tvs,gtvs')) scope
+\end{code}
+
+
+\begin{code}
+tcLookupValue :: Name -> NF_TcM s Id -- Panics if not found
+tcLookupValue name
= case maybeWiredInIdName name of
Just id -> returnNF_Tc id
- Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupWithDefaultUFM gve def name)
+ Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ returnNF_Tc (lookupWithDefaultUFM ve def name)
where
- def = pprPanic "tcLookupGlobalValue:" (ppr name)
+ def = pprPanic "tcLookupValue:" (ppr name)
-tcLookupGlobalValueMaybe :: Name -> NF_TcM s (Maybe Id)
-tcLookupGlobalValueMaybe name
+tcLookupValueMaybe :: Name -> NF_TcM s (Maybe Id)
+tcLookupValueMaybe name
= case maybeWiredInIdName name of
Just id -> returnNF_Tc (Just id)
- Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupUFM gve name)
-
-
-tcLookupGlobalValueByKey :: Unique -> NF_TcM s Id
-tcLookupGlobalValueByKey uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupGlobalByKey gve uniq)
+ Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ returnNF_Tc (lookupUFM ve name)
-lookupGlobalByKey :: GlobalValueEnv -> Unique -> Id
-lookupGlobalByKey gve uniq
- = lookupWithDefaultUFM_Directly gve def uniq
- where
-#ifdef DEBUG
- def = pprPanic "tcLookupGlobalValueByKey:" (pprUnique10 uniq)
-#else
- def = panic "tcLookupGlobalValueByKey"
-#endif
-
-tcLookupGlobalValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id)
-tcLookupGlobalValueByKeyMaybe uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc (lookupUFM_Directly gve uniq)
+tcLookupValueByKey :: Unique -> NF_TcM s Id -- Panics if not found
+tcLookupValueByKey key
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ returnNF_Tc (explicitLookupValueByKey ve key)
-tcGetGlobalValEnv :: NF_TcM s GlobalValueEnv
-tcGetGlobalValEnv
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) ->
- returnNF_Tc gve
+tcLookupValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id)
+tcLookupValueByKeyMaybe key
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ returnNF_Tc (lookupUFM_Directly ve key)
-tcSetGlobalValEnv :: GlobalValueEnv -> TcM s a -> TcM s a
-tcSetGlobalValEnv gve scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce _ lve gtvs) ->
- tcSetEnv (TcEnv tve tce ce gve lve gtvs) scope
+tcGetValueEnv :: NF_TcM s ValueEnv
+tcGetValueEnv
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) ->
+ returnNF_Tc ve
+tcSetValueEnv :: ValueEnv -> TcM s a -> TcM s a
+tcSetValueEnv ve scope
+ = tcGetEnv `thenNF_Tc` \ (TcEnv ue te _ gtvs) ->
+ tcSetEnv (TcEnv ue te ve gtvs) scope
-- Non-monadic version, environment given explicitly
-tcExplicitLookupGlobal :: GlobalValueEnv -> Name -> Maybe Id
-tcExplicitLookupGlobal gve name
+explicitLookupValueByKey :: ValueEnv -> Unique -> Id
+explicitLookupValueByKey ve key
+ = lookupWithDefaultUFM_Directly ve def key
+ where
+ def = pprPanic "lookupValueByKey:" (pprUnique10 key)
+
+explicitLookupValue :: ValueEnv -> Name -> Maybe Id
+explicitLookupValue ve name
= case maybeWiredInIdName name of
Just id -> Just id
- Nothing -> lookupUFM gve name
+ Nothing -> lookupUFM ve name
-- Extract the IdInfo from an IfaceSig imported from an interface file
-tcAddImportedIdInfo :: GlobalValueEnv -> Id -> Id
+tcAddImportedIdInfo :: ValueEnv -> Id -> Id
tcAddImportedIdInfo unf_env id
| isLocallyDefined id -- Don't look up locally defined Ids, because they
-- have explicit local definitions, so we get a black hole!
= id
| otherwise
- = id `setIdInfo` new_info
+ = id `lazySetIdInfo` new_info
-- The Id must be returned without a data dependency on maybe_id
where
new_info = -- pprTrace "tcAdd" (ppr id) $
- case tcExplicitLookupGlobal unf_env (getName id) of
- Nothing -> noIdInfo
+ case explicitLookupValue unf_env (getName id) of
+ Nothing -> vanillaIdInfo
Just imported_id -> idInfo imported_id
-- ToDo: could check that types are the same
\end{code}
-Constructing new Ids
-~~~~~~~~~~~~~~~~~~~~
+%************************************************************************
+%* *
+\subsection{Constructing new Ids}
+%* *
+%************************************************************************
\begin{code}
-newLocalId :: OccName -> TcType s -> NF_TcM s (TcIdBndr s)
-newLocalId name ty
+newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM s TcId
+newLocalId name ty loc
= tcGetUnique `thenNF_Tc` \ uniq ->
- returnNF_Tc (mkUserLocal name uniq ty)
-
-newLocalIds :: [OccName] -> [TcType s] -> NF_TcM s [TcIdBndr s]
-newLocalIds names tys
- = tcGetUniques (length names) `thenNF_Tc` \ uniqs ->
- let
- new_ids = zipWith3Equal "newLocalIds" mk_id names uniqs tys
- mk_id name uniq ty = mkUserLocal name uniq ty
- in
- returnNF_Tc new_ids
+ returnNF_Tc (mkUserLocal name uniq ty loc)
-newSpecPragmaId :: Name -> TcType s -> NF_TcM s (TcIdBndr s)
+newSpecPragmaId :: Name -> TcType -> NF_TcM s TcId
newSpecPragmaId name ty
= tcGetUnique `thenNF_Tc` \ uniq ->
- returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty)
+ returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name))
\end{code}
-\begin{code}
-classAsTyConErr name
- = ptext SLIT("Class used as a type constructor:") <+> ppr name
-
-tyConAsClassErr name
- = ptext SLIT("Type constructor used as a class:") <+> ppr name
+%************************************************************************
+%* *
+\subsection{Errors}
+%* *
+%************************************************************************
+\begin{code}
badCon con_id
= quotes (ppr con_id) <+> ptext SLIT("is not a data constructor")
badPrimOp op
= quotes (ppr op) <+> ptext SLIT("is not a primop")
+
+uvNameOutOfScope name
+ = ptext SLIT("UVar") <+> quotes (ppr name) <+> ptext SLIT("is not in scope")
+
+tyNameOutOfScope name
+ = quotes (ppr name) <+> ptext SLIT("is not in scope")
\end{code}