X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=49da0db77b874343b43b2f549bdf60c772ef36da;hb=c3cf681e8f65430d4e0dcef08c8f7b75332a034e;hp=9bf814d05b591d4b0ff9be9ff7c608ca5c6b85d0;hpb=1fb1ab5d53a09607e7f6d2450806760688396387;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 9bf814d..49da0db 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,211 +1,259 @@ \begin{code} -#include "HsVersions.h" - module TcEnv( - TcEnv, + TcId, TcIdSet, tcInstId, + tcLookupDataCon, - initEnv, getEnv_LocalIds, getEnv_TyCons, getEnv_Classes, + TcEnv, ValueEnv, TcTyThing(..), + + initEnv, getEnvTyCons, getEnvClasses, getAllEnvTyCons, - tcExtendTyVarEnv, tcLookupTyVar, + tcExtendUVarEnv, tcLookupUVar, + + tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars, - tcExtendTyConEnv, tcLookupTyCon, tcLookupTyConByKey, - tcExtendClassEnv, tcLookupClass, tcLookupClassByKey, - tcGetTyConsAndClasses, + tcLookupTy, + tcLookupTyCon, tcLookupTyConByKey, + tcLookupClass, tcLookupClassByKey, tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcLookupLocalValue, tcLookupLocalValueOK, tcLookupLocalValueByKey, - tcLookupGlobalValue, tcLookupGlobalValueByKey, tcLookupGlobalValueMaybe, + tcGetValueEnv, tcSetValueEnv, tcAddImportedIdInfo, - tcLookupGlobalValueByKeyMaybe, - newMonoIds, newLocalIds, newLocalId, - tcGetGlobalTyVars, tcExtendGlobalTyVars - ) where + tcLookupValue, tcLookupValueMaybe, + tcLookupValueByKey, tcLookupValueByKeyMaybe, + explicitLookupValueByKey, explicitLookupValue, + valueEnvIds, + newLocalId, newSpecPragmaId, + tcGetGlobalTyVars, tcExtendGlobalTyVars, -IMP_Ubiq() -IMPORT_DELOOPER(TcMLoop) -- for paranoia checking + badCon, badPrimOp + ) where -import HsTypes ( HsTyVar(..) ) -import Id ( SYN_IE(Id), GenId, idType, mkUserLocal, mkUserId, replaceIdInfo, getIdInfo ) -import PragmaInfo ( PragmaInfo(..) ) -import TcHsSyn ( SYN_IE(TcIdBndr), TcIdOcc(..) ) -import TcKind ( TcKind, newKindVars, newKindVar, tcDefaultKind, kindToTcKind ) -import TcType ( SYN_IE(TcType), TcMaybe, SYN_IE(TcTyVar), SYN_IE(TcTyVarSet), - newTyVarTys, tcInstTyVars, zonkTcTyVars +#include "HsVersions.h" + +import HsTypes ( HsTyVar, getTyVarName ) +import Id ( mkUserLocal, isDataConId_maybe ) +import MkId ( mkSpecPragmaId ) +import Var ( TyVar, Id, setVarName, + idType, lazySetIdInfo, idInfo, tyVarKind, UVar, + ) +import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType, + tcInstTyVars, zonkTcTyVars, + TcKind, kindToTcKind + ) +import VarEnv +import VarSet +import Type ( Kind, superKind, + tyVarsOfType, tyVarsOfTypes, mkTyVarTy, + splitForAllTys, splitRhoTy, splitFunTys, + splitAlgTyConApp_maybe, getTyVar ) -import TyVar ( unionTyVarSets, emptyTyVarSet ) -import Type ( tyVarsOfTypes, splitForAllTy ) -import TyCon ( TyCon, tyConKind, synTyConArity ) -import Class ( SYN_IE(Class), GenClass, classSig ) +import Subst ( substTy ) +import UsageSPUtils ( unannotTy ) +import DataCon ( DataCon ) +import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon ) +import Class ( Class, classTyCon ) import TcMonad -import IdInfo ( noIdInfo ) -import Name ( Name, OccName(..), getSrcLoc, occNameString, - maybeWiredInTyConName, maybeWiredInIdName, pprSym - ) -import PprStyle -import Pretty -import Unique ( pprUnique10{-, pprUnique ToDo:rm-} ) -import UniqFM -import Util ( zipEqual, zipWithEqual, zipWith3Equal, zipLazy, - panic, pprPanic{-, pprTrace ToDo:rm-} +import BasicTypes ( Arity ) +import IdInfo ( vanillaIdInfo ) +import Name ( Name, OccName, nameOccName, getSrcLoc, + maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined, + NamedThing(..) ) +import Unique ( pprUnique10, Unique, Uniquable(..) ) +import FiniteMap ( lookupFM, addToFM ) +import UniqFM +import Unique ( Uniquable(..) ) +import Util ( zipEqual, zipWith3Equal, mapAccumL ) +import Bag ( bagToList ) +import Maybes ( maybeToBool, catMaybes ) +import SrcLoc ( SrcLoc ) +import FastString ( FastString ) +import Outputable \end{code} -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{TcId} +%* * +%************************************************************************ -\begin{code} -data TcEnv s = TcEnv - (TyVarEnv s) - (TyConEnv s) - (ClassEnv s) - (ValueEnv Id) -- Globals - (ValueEnv (TcIdBndr s)) -- Locals - (MutableVar s (TcTyVarSet s)) -- Free type variables of locals - -- ...why mutable? see notes with tcGetGlobalTyVars - -type TyVarEnv 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) -type ValueEnv id = UniqFM id - -initEnv :: MutableVar s (TcTyVarSet s) -> TcEnv s -initEnv mut = TcEnv emptyUFM emptyUFM emptyUFM emptyUFM emptyUFM mut - -getEnv_LocalIds (TcEnv _ _ _ _ ls _) = eltsUFM ls -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) -> +type TcId = Id -- Type may be a TcType +type TcIdSet = IdSet + +tcLookupDataCon :: Name -> TcM s (DataCon, [TcType], TcType) +tcLookupDataCon con_name + = tcLookupValue con_name `thenNF_Tc` \ con_id -> + case isDataConId_maybe con_id of { + Nothing -> failWithTc (badCon con_id); + Just data_con -> + + tcInstId con_id `thenNF_Tc` \ (_, _, con_tau) -> + -- Ignore the con_theta; overloaded constructors only + -- behave differently when called, not when used for + -- matching. + let + (arg_tys, result_ty) = splitFunTys con_tau + in + ASSERT( maybeToBool (splitAlgTyConApp_maybe result_ty) ) + returnTc (data_con, arg_tys, result_ty) } + +-- 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], -- It's instantiated type + TcThetaType, -- + TcType) -- +tcInstId id + = let + (tyvars, rho) = splitForAllTys (unannotTy (idType id)) + in + tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) -> let - tve' = addListToUFM tve (zipEqual "tcTyVarScope" names kinds_w_types) + rho' = substTy tenv rho + (theta', tau') = splitRhoTy rho' in - tcSetEnv (TcEnv tve' tce ce gve lve gtvs) scope + returnNF_Tc (tyvars', theta', tau') \end{code} -The Kind, TyVar, Class and TyCon envs -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Extending the environments. Notice the uses of @zipLazy@, which makes sure -that the knot-tied TyVars, TyCons and Classes aren't looked at too early. +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} -tcExtendTyConEnv :: [(Name,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) -> - let - tce' = addListToUFM tce [ (name, (kind, arity, tycon)) - | ((name,arity), (kind,tycon)) - <- zipEqual "tcExtendTyConEnv" names_w_arities (kinds `zipLazy` tycons) - ] - in - tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope `thenTc` \ result -> - mapNF_Tc tcDefaultKind kinds `thenNF_Tc_` - returnTc result +%************************************************************************ +%* * +\subsection{TcEnv} +%* * +%************************************************************************ +Data type declarations +~~~~~~~~~~~~~~~~~~~~~ -tcExtendClassEnv :: [Name] -> [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 (zipEqual "tcExtendClassEnv" names (kinds `zipLazy` classes)) - in - tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope `thenTc` \ result -> - mapNF_Tc tcDefaultKind kinds `thenNF_Tc_` - returnTc result +\begin{code} +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 UsageEnv +~~~~~~~~~~~~ -Looking up in the environments. +Extending the usage environment. \begin{code} -tcLookupTyVar name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM tve (pprPanic "tcLookupTyVar:" (ppr PprShowAll name)) name) - +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} -tcLookupTyCon name - = case maybeWiredInTyConName name of - Just tc -> returnTc (kindToTcKind (tyConKind tc), synTyConArity tc, tc) - Nothing -> 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 _ -> failTc (classAsTyConErr name) - Nothing -> pprPanic "tcLookupTyCon:" (ppr PprDebug name) - -tcLookupTyConByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce - (pprPanic "tcLookupTyCon:" (pprUnique10 uniq)) - uniq - in - returnNF_Tc tycon +Looking up in the environments. -tcLookupClass name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> --- 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))]) $ - case lookupUFM ce name of - Just stuff -> returnTc stuff - Nothing -> -- Could be that he's using a type constructor as a class - case lookupUFM tce name of - Just _ -> failTc (tyConAsClassErr name) - Nothing -> pprPanic "tcLookupClass:" (ppr PprShowAll 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 +\begin{code} +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 [(uniqueOf 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 `unionTyVarSets` 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 + ] + +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 - tcSetEnv (TcEnv tve tce ce gve lve' gtvs') scope +tc_extend_gtvs gtvs extra_global_tvs + = tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> + let + new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs + in + tcNewMutVar new_global_tyvars \end{code} @tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment. @@ -213,129 +261,218 @@ To improve subsequent calls to the same function it writes the zonked set back i 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) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - zonkTcTyVars global_tvs `thenNF_Tc` \ global_tvs' -> - tcWriteMutVar gtvs global_tvs' `thenNF_Tc_` + = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve (_,gtvs)) -> + tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> + zonkTcTyVars (varSetElems global_tvs) `thenNF_Tc` \ global_tys' -> + let + global_tvs' = (tyVarsOfTypes global_tys') + in + 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 `unionTyVarSets` 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) + +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) -tcLookupGlobalValue :: Name -> NF_TcM s Id +%************************************************************************ +%* * +\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 + +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} + -tcLookupGlobalValue name +\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 PprDebug 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 (lookupWithDefaultUFM_Directly gve def uniq) + Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) -> + returnNF_Tc (lookupUFM ve name) + +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) + +tcLookupValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id) +tcLookupValueByKeyMaybe key + = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve gtvs) -> + returnNF_Tc (lookupUFM_Directly ve key) + +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 +explicitLookupValueByKey :: ValueEnv -> Unique -> Id +explicitLookupValueByKey ve key + = lookupWithDefaultUFM_Directly ve def key where -#ifdef DEBUG - def = pprPanic "tcLookupGlobalValueByKey:" (pprUnique10 uniq) -#else - def = panic "tcLookupGlobalValueByKey" -#endif + def = pprPanic "lookupValueByKey:" (pprUnique10 key) -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) +explicitLookupValue :: ValueEnv -> Name -> Maybe Id +explicitLookupValue ve name + = case maybeWiredInIdName name of + Just id -> Just id + Nothing -> lookupUFM ve name -- Extract the IdInfo from an IfaceSig imported from an interface file -tcAddImportedIdInfo :: Id -> NF_TcM s Id -tcAddImportedIdInfo id - = tcLookupGlobalValueMaybe (getName id) `thenNF_Tc` \ maybe_id -> - let - new_info = case maybe_id of - Nothing -> noIdInfo - Just imported_id -> getIdInfo imported_id - -- ToDo: could check that types are the same - in - returnNF_Tc (id `replaceIdInfo` new_info) +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 `lazySetIdInfo` new_info -- The Id must be returned without a data dependency on maybe_id + where + new_info = -- pprTrace "tcAdd" (ppr id) $ + 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} --- Uses the Name as the Name of the Id -newMonoIds :: [Name] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a - -newMonoIds names kind m - = newTyVarTys no_of_names kind `thenNF_Tc` \ tys -> - let - new_ids = zipWithEqual "newMonoIds" mk_id names tys - mk_id name ty = mkUserId name ty NoPragmaInfo - in - tcExtendLocalValEnv names new_ids (m new_ids) - where - no_of_names = length names - -newLocalId :: OccName -> TcType s -> NF_TcM s (TcIdBndr s) -newLocalId name ty - = tcGetSrcLoc `thenNF_Tc` \ loc -> - tcGetUnique `thenNF_Tc` \ uniq -> +newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM s TcId +newLocalId name ty loc + = tcGetUnique `thenNF_Tc` \ uniq -> returnNF_Tc (mkUserLocal name uniq ty loc) -newLocalIds :: [OccName] -> [TcType s] -> NF_TcM s [TcIdBndr s] -newLocalIds names tys - = tcGetSrcLoc `thenNF_Tc` \ loc -> - 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 loc - in - returnNF_Tc new_ids +newSpecPragmaId :: Name -> TcType -> NF_TcM s TcId +newSpecPragmaId name ty + = tcGetUnique `thenNF_Tc` \ uniq -> + returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name)) \end{code} + +%************************************************************************ +%* * +\subsection{Errors} +%* * +%************************************************************************ + \begin{code} -classAsTyConErr name sty - = ppBesides [ppPStr SLIT("Class used as a type constructor: "), pprSym sty name] +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") -tyConAsClassErr name sty - = ppBesides [ppPStr SLIT("Type constructor used as a class: "), pprSym sty name] +tyNameOutOfScope name + = quotes (ppr name) <+> ptext SLIT("is not in scope") \end{code}