- Fixes for bootstrapping with 3.01.
- Use 'official' extension interfaces rather than internal prelude
modules (such as ArrBase) where possible.
- Remove some cruft.
- Delete some unused imports found by '-fwarn-unused-imports'.
#include "HsVersions.h"
-import HsSyn ( HsLit(..), HsExpr(..), MonoBinds(..) )
+import HsSyn ( HsLit(..), HsExpr(..), MonoBinds )
import RnHsSyn ( RenamedArithSeqInfo, RenamedHsExpr )
import TcHsSyn ( TcExpr, TcIdOcc(..), TcIdBndr,
- TcDictBinds, TcMonoBinds,
mkHsTyApp, mkHsDictApp, tcIdTyVars, zonkTcId
)
import TcMonad
import TcEnv ( tcLookupGlobalValueByKey, tcLookupTyConByKey )
import TcType ( TcThetaType,
- TcType, TcRhoType, TcTauType, TcMaybe, TcTyVarSet,
- tcInstType, zonkTcType, zonkTcTypes, tcSplitForAllTy, tcSplitRhoTy,
+ TcType, TcTauType, TcMaybe, TcTyVarSet,
+ tcInstType, zonkTcType, zonkTcTypes, tcSplitForAllTy,
zonkTcThetaType
)
-import Bag ( emptyBag, unitBag, unionBags, unionManyBags, bagToList,
+import Bag ( emptyBag, unitBag, unionBags, unionManyBags,
listToBag, consBag, Bag )
import Class ( classInstEnv,
Class, ClassInstEnv
GenIdSet, elementOfIdSet
)
import PrelInfo ( isStandardClass, isCcallishClass, isNoDictClass )
-import Name ( OccName(..), Name, mkLocalName,
- mkSysLocalName, occNameString, getOccName )
+import Name ( OccName(..), Name, occNameString, getOccName )
import PprType ( TyCon, pprConstraint )
import SpecEnv ( SpecEnv, matchSpecEnv, addToSpecEnv )
import SrcLoc ( SrcLoc )
import Type ( Type, ThetaType, instantiateTy, instantiateThetaTy, matchTys,
isTyVarTy, mkDictTy, splitForAllTys, splitSigmaTy,
- splitRhoTy, matchTy, tyVarsOfType, tyVarsOfTypes,
+ splitRhoTy, tyVarsOfType, tyVarsOfTypes,
mkSynTy
)
import TyVar ( zipTyVarEnv, lookupTyVarEnv, unionTyVarSets )
fromIntClassOpKey, fromIntegerClassOpKey, Unique
)
import Maybes ( MaybeErr, expectJust )
-import Util ( thenCmp, zipEqual, zipWithEqual, isIn )
+import Util ( thenCmp, zipWithEqual )
import Outputable
\end{code}
RenamedMonoBinds
)
import TcHsSyn ( TcHsBinds, TcMonoBinds,
- TcExpr, TcIdOcc(..), TcIdBndr,
+ TcIdOcc(..), TcIdBndr,
tcIdType
)
import TcSimplify ( bindInstsOfLocalFuns )
import TcType ( TcType, TcThetaType, TcTauType,
TcTyVarSet, TcTyVar,
- newTyVarTy, newTcTyVar, tcInstSigType, newTyVarTys,
+ newTyVarTy, newTcTyVar, tcInstSigType,
zonkTcType, zonkTcTypes, zonkTcThetaType, zonkTcTyVar
)
import Unify ( unifyTauTy, unifyTauTyLists )
import Kind ( isUnboxedTypeKind, mkTypeKind, isTypeKind, mkBoxedTypeKind )
import Id ( GenId, idType, mkUserId )
import IdInfo ( noIdInfo )
-import Maybes ( maybeToBool, assocMaybe, catMaybes )
+import Maybes ( maybeToBool, assocMaybe )
import Name ( getOccName, getSrcLoc, Name )
import PragmaInfo ( PragmaInfo(..) )
import Type ( mkTyVarTy, mkTyVarTys, isTyVarTy, tyVarsOfTypes,
- mkSigmaTy, splitSigmaTy, mkForAllTys, mkFunTys, getTyVar, mkDictTy,
+ splitSigmaTy, mkForAllTys, mkFunTys, getTyVar, mkDictTy,
splitRhoTy, mkForAllTy, splitForAllTys )
import TyVar ( GenTyVar, TyVar, tyVarKind, mkTyVarSet, minusTyVarSet, emptyTyVarSet,
elementOfTyVarSet, unionTyVarSets, tyVarSetToList )
-import Bag ( bagToList, foldrBag, isEmptyBag )
-import Util ( isIn, zipEqual, zipWithEqual, zipWith3Equal, hasNoDups, assoc )
+import Bag ( bagToList, foldrBag, )
+import Util ( isIn, hasNoDups, assoc )
import Unique ( Unique )
import BasicTypes ( TopLevelFlag(..), RecFlag(..) )
import SrcLoc ( SrcLoc )
#include "HsVersions.h"
import HsSyn ( HsDecl(..), ClassDecl(..), Sig(..), MonoBinds(..),
- InPat(..),
- andMonoBinds, collectMonoBinders,
- getTyVarName
+ InPat(..), andMonoBinds, getTyVarName
)
import HsPragmas ( ClassPragmas(..) )
import BasicTypes ( NewOrData(..), TopLevelFlag(..), RecFlag(..) )
import RnHsSyn ( RenamedClassDecl(..), RenamedClassPragmas(..),
RenamedClassOpSig(..), RenamedMonoBinds,
- RenamedGenPragmas(..), RenamedContext(..), RenamedHsDecl
+ RenamedContext(..), RenamedHsDecl
)
-import TcHsSyn ( TcHsBinds, TcMonoBinds, TcExpr,
- mkHsTyApp, mkHsTyLam, mkHsDictApp, mkHsDictLam, tcIdType )
+import TcHsSyn ( TcMonoBinds )
import Inst ( Inst, InstOrigin(..), LIE, emptyLIE, plusLIE, newDicts, newMethod )
-import TcEnv ( TcIdOcc(..), newLocalIds, tcAddImportedIdInfo,
+import TcEnv ( TcIdOcc(..), tcAddImportedIdInfo,
tcLookupClass, tcLookupTyVar,
tcExtendGlobalTyVars )
import TcBinds ( tcBindWithSigs, checkSigTyVars, sigCtxt, sigThetaCtxt, TcSigInfo(..) )
)
import PragmaInfo ( PragmaInfo(..) )
-import Bag ( bagToList, unionManyBags )
+import Bag ( unionManyBags )
import Class ( mkClass, classBigSig, Class )
-import CmdLineOpts ( opt_PprUserLength, opt_GlasgowExts )
+import CmdLineOpts ( opt_GlasgowExts )
import Id ( Id, StrictnessMark(..),
mkSuperDictSelId, mkMethodSelId,
mkDefaultMethodId, getIdUnfolding, mkDataCon,
)
import CoreUnfold ( getUnfoldingTemplate )
import IdInfo
-import Name ( Name, isLocallyDefined, moduleString, getSrcLoc,
- OccName, nameOccName,
- nameString, NamedThing(..) )
+import Name ( Name, isLocallyDefined, OccName, nameOccName,
+ NamedThing(..) )
import Outputable
-import SrcLoc ( mkGeneratedSrcLoc )
import Type ( mkFunTy, mkTyVarTy, mkTyVarTys, mkDictTy, splitRhoTy,
- mkForAllTy, mkSigmaTy, splitSigmaTy, mkForAllTys, Type, ThetaType
+ mkSigmaTy, mkForAllTys, Type, ThetaType
)
-import TysWiredIn ( stringTy )
-import TyVar ( unitTyVarSet, tyVarSetToList, mkTyVarSet, tyVarKind, TyVar )
+import TyVar ( mkTyVarSet, tyVarKind, TyVar )
import TyCon ( mkDataTyCon )
import Kind ( mkBoxedTypeKind, mkArrowKind )
import Unique ( Unique, Uniquable(..) )
#include "HsVersions.h"
import HsSyn ( HsDecl(..), DefaultDecl(..) )
-import RnHsSyn ( RenamedHsDecl(..), RenamedDefaultDecl(..) )
+import RnHsSyn ( RenamedHsDecl(..) )
import TcMonad
-import Inst ( InstOrigin(..) )
-import TcEnv ( TcIdOcc, tcLookupClassByKey )
+import TcEnv ( tcLookupClassByKey )
import TcMonoType ( tcHsType )
import TcSimplify ( tcSimplifyCheckThetas )
-import TysWiredIn ( intTy, doubleTy, unitTy )
+import TysWiredIn ( intTy, doubleTy )
import Type ( Type )
import Unique ( numClassKey )
import ErrUtils ( addShortErrLocLine )
#include "HsVersions.h"
import HsSyn ( HsBinds(..), MonoBinds(..), collectMonoBinders )
-import HsPragmas ( InstancePragmas(..) )
import RdrHsSyn ( RdrName, RdrNameMonoBinds )
-import RnHsSyn ( RenamedHsBinds, RenamedMonoBinds, RenamedFixityDecl )
+import RnHsSyn ( RenamedHsBinds, RenamedMonoBinds )
import TcMonad
import Inst ( InstanceMapper )
-import TcEnv ( TcIdOcc, getEnv_TyCons, tcLookupClassByKey )
+import TcEnv ( getEnv_TyCons, tcLookupClassByKey )
import TcKind ( TcKind )
import TcGenDeriv -- Deriv stuff
import TcInstUtil ( InstInfo(..), mkInstanceRelatedIds, buildInstanceEnvs )
import RnBinds ( rnMethodBinds, rnTopMonoBinds )
import RnEnv ( newDfunName, bindLocatedLocalsRn )
-import RnMonad ( RnM, RnDown, GDown, SDown, RnNameSupply(..),
- setNameSupplyRn, renameSourceCode, thenRn, mapRn, returnRn )
+import RnMonad ( RnM, RnDown, SDown, RnNameSupply(..),
+ renameSourceCode, thenRn, mapRn, returnRn )
-import Bag ( Bag, emptyBag, isEmptyBag, unionBags, listToBag )
+import Bag ( Bag, emptyBag, unionBags, listToBag )
import Class ( classKey, Class )
import ErrUtils ( ErrMsg )
import Id ( dataConArgTys, isNullaryDataCon, mkDictFunId )
import PrelInfo ( needsDataDeclCtxtClassKeys )
import Maybes ( maybeToBool )
-import Name ( isLocallyDefined, getSrcLoc, ExportFlag(..), Provenance,
+import Name ( isLocallyDefined, getSrcLoc, Provenance,
Name{--O only-}, Module, NamedThing(..)
)
import SrcLoc ( mkGeneratedSrcLoc, SrcLoc )
)
import TysPrim ( voidTy )
import TyVar ( GenTyVar, TyVar )
-import UniqFM ( emptyUFM )
import Unique -- Keys stuff
import Bag ( bagToList )
-import Util ( zipWithEqual, zipEqual, sortLt, removeDups, assoc,
- thenCmp, cmpList
- )
+import Util ( zipWithEqual, sortLt, removeDups, assoc, thenCmp )
import Outputable
\end{code}
_interface_ TcEnv 1
_exports_
-TcEnv TcEnv initEnv;
+TcEnv TcEnv;
_declarations_
1 data TcEnv a;
-1 initEnv _:_ _forall_ [a] => ArrBase.MutableVar a (TcType.TcTyVarSet a) -> TcEnv.TcEnv a ;;
#include "HsVersions.h"
-import HsTypes ( HsTyVar(..) )
import Id ( Id, GenId, idType, mkUserLocal, mkUserId, replaceIdInfo, getIdInfo )
import PragmaInfo ( PragmaInfo(..) )
-import TcKind ( TcKind, newKindVars, newKindVar, tcDefaultKind, kindToTcKind, Kind )
+import TcKind ( TcKind, kindToTcKind, Kind )
import TcType ( TcType, TcMaybe, TcTyVar, TcTyVarSet, TcThetaType,
newTyVarTys, tcInstTyVars, zonkTcTyVars, tcInstType
)
-import TyVar ( mkTyVarSet, unionTyVarSets, emptyTyVarSet, tyVarSetToList, TyVar )
+import TyVar ( mkTyVarSet, unionTyVarSets, emptyTyVarSet, TyVar )
import PprType ( GenTyVar )
import Type ( tyVarsOfType, tyVarsOfTypes, splitForAllTys, splitRhoTy )
import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon, Arity )
import TcMonad
import IdInfo ( noIdInfo )
-import Name ( Name, OccName(..), getSrcLoc, occNameString,
+import Name ( Name, OccName(..),
maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined,
NamedThing(..)
)
import Unique ( pprUnique10{-, pprUnique ToDo:rm-}, Unique, Uniquable(..) )
import UniqFM
-import Util ( zipEqual, zipWithEqual, zipWith3Equal, zipLazy
- )
+import Util ( zipEqual, zipWithEqual, zipWith3Equal )
import Maybes ( maybeToBool )
import Outputable
\end{code}
import HsSyn ( HsExpr(..), HsLit(..), ArithSeqInfo(..),
HsBinds(..), Stmt(..), DoOrListComp(..),
- pprParendExpr, failureFreePat, collectPatBinders
+ failureFreePat, collectPatBinders
)
import RnHsSyn ( RenamedHsExpr,
RenamedStmt, RenamedRecordBinds
import TcBinds ( tcBindsAndThen, checkSigTyVars, sigThetaCtxt )
import TcEnv ( TcIdOcc(..), tcInstId,
tcLookupLocalValue, tcLookupGlobalValue, tcLookupClassByKey,
- tcLookupGlobalValueByKey, newMonoIds, tcGetGlobalTyVars,
+ tcLookupGlobalValueByKey, newMonoIds,
tcExtendGlobalTyVars, tcLookupGlobalValueMaybe,
tcLookupTyCon
)
import TcType ( TcType, TcMaybe(..),
tcInstType, tcInstSigTcType, tcInstTyVars,
tcInstSigType, tcInstTcType, tcInstTheta, tcSplitRhoTy,
- newTyVarTy, newTyVarTys, zonkTcTyVars, zonkTcType )
+ newTyVarTy, newTyVarTys, zonkTcType )
import TcKind ( TcKind )
import Class ( Class )
)
import Kind ( Kind, mkBoxedTypeKind, mkTypeKind, mkArrowKind )
import Name ( Name{-instance Eq-} )
-import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys, mkRhoTy,
+import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys,
splitFunTy_maybe, splitFunTys,
mkTyConApp,
splitForAllTys, splitRhoTy, splitSigmaTy,
- isTauTy, mkFunTys, tyVarsOfType, tyVarsOfTypes,
+ isTauTy, tyVarsOfType, tyVarsOfTypes,
splitForAllTy_maybe, splitAlgTyConApp, splitAlgTyConApp_maybe
)
-import TyVar ( TyVarSet, emptyTyVarEnv, zipTyVarEnv,
- unionTyVarSets, elementOfTyVarSet, mkTyVarSet, tyVarSetToList
+import TyVar ( emptyTyVarEnv, zipTyVarEnv,
+ elementOfTyVarSet, mkTyVarSet, tyVarSetToList
)
import TyCon ( tyConDataCons )
import TysPrim ( intPrimTy, charPrimTy, doublePrimTy,
- floatPrimTy, addrPrimTy, realWorldTy
- )
-import TysWiredIn ( addrTy, mkTupleTy,
- boolTy, charTy, stringTy, mkListTy
+ floatPrimTy, addrPrimTy
)
+import TysWiredIn ( boolTy, charTy, stringTy )
import PrelInfo ( ioTyCon_NAME )
-import Unify ( unifyTauTy, unifyTauTyList, unifyTauTyLists,
- unifyFunTy, unifyListTy, unifyTupleTy
- )
+import Unify ( unifyTauTy, unifyFunTy, unifyListTy, unifyTupleTy )
import Unique ( Unique, cCallableClassKey, cReturnableClassKey,
enumFromClassOpKey, enumFromThenClassOpKey,
enumFromToClassOpKey, enumFromThenToClassOpKey,
import Inst ( Inst, LIE, plusLIE )
import TcBinds ( tcBindsAndThen )
import TcExpr ( tcExpr, tcStmt )
-import TcType ( TcType, newTyVarTy )
-import TcEnv ( TcIdOcc(..) )
-
-import TysWiredIn ( boolTy )
+import TcType ( TcType )
\end{code}
\begin{code}
import HsSyn ( HsDecl(..), IfaceSig(..) )
import TcMonad
import TcMonoType ( tcHsType, tcHsTypeKind )
-import TcEnv ( tcLookupGlobalValue, tcExtendTyVarEnv, tcExtendGlobalValEnv,
- tcLookupTyConByKey, tcLookupGlobalValueMaybe, tcLookupLocalValue,
+import TcEnv ( tcExtendTyVarEnv, tcExtendGlobalValEnv,
+ tcLookupTyConByKey, tcLookupGlobalValueMaybe,
tcExplicitLookupGlobal
)
import TcKind ( TcKind, kindToTcKind )
#include "HsVersions.h"
-import HsSyn ( HsDecl(..), InstDecl(..), HsType(..),
+import HsSyn ( HsDecl(..), InstDecl(..),
HsBinds(..), MonoBinds(..), GRHSsAndBinds(..), GRHS(..),
HsExpr(..), InPat(..), HsLit(..),
unguardedRHS,
collectMonoBinders, andMonoBinds
)
import RnHsSyn ( RenamedHsBinds, RenamedMonoBinds,
- RenamedInstDecl, RenamedFixityDecl, RenamedHsExpr,
- RenamedSig, RenamedSpecInstSig, RenamedHsDecl
+ RenamedInstDecl, RenamedHsExpr,
+ RenamedSig, RenamedHsDecl
)
-import TcHsSyn ( TcHsBinds,
- TcMonoBinds, TcExpr, TcIdOcc(..), TcIdBndr,
- tcIdType, maybeBoxedPrimType,
- mkHsTyLam, mkHsTyApp,
- mkHsDictLam, mkHsDictApp )
+import TcHsSyn ( TcMonoBinds, TcIdOcc(..), TcIdBndr,
+ maybeBoxedPrimType, mkHsTyLam, mkHsTyApp,
+ )
import TcBinds ( tcPragmaSigs, sigThetaCtxt )
import TcClassDcl ( tcMethodBind, badMethodErr )
import TcMonad
import RnMonad ( RnNameSupply )
-import Inst ( Inst, InstOrigin(..), InstanceMapper,
- instToId, newDicts, newMethod, LIE, emptyLIE, plusLIE )
+import Inst ( Inst, InstOrigin(..),
+ newDicts, LIE, emptyLIE, plusLIE )
import PragmaInfo ( PragmaInfo(..) )
import TcDeriv ( tcDeriving )
-import TcEnv ( tcLookupClass, newLocalId, tcGetGlobalTyVars,
- tcExtendGlobalValEnv, tcAddImportedIdInfo
- )
-import TcInstUtil ( InstInfo(..), mkInstanceRelatedIds, buildInstanceEnvs, classDataCon )
+import TcEnv ( tcExtendGlobalValEnv, tcAddImportedIdInfo )
+import TcInstUtil ( InstInfo(..), mkInstanceRelatedIds, classDataCon )
import TcKind ( TcKind, unifyKind )
-import TcMatches ( tcMatchesFun )
-import TcMonoType ( tcTyVarScope, tcContext, tcHsTypeKind, tcHsType )
+import TcMonoType ( tcHsType )
import TcSimplify ( tcSimplifyAndCheck )
import TcType ( TcType, TcTyVar, TcTyVarSet,
- zonkSigTyVar,
- tcInstSigTyVars, tcInstType, tcInstSigTcType,
- tcInstTheta, tcInstTcType
+ zonkSigTyVar, tcInstSigTyVars, tcInstType, tcInstTheta
)
-import Unify ( unifyTauTy, unifyTauTyLists )
-
import Bag ( emptyBag, unitBag, unionBags, unionManyBags,
- concatBag, foldBag, bagToList, listToBag,
- Bag
- )
-import CmdLineOpts ( opt_GlasgowExts,
- opt_SpecialiseOverloaded, opt_WarnMissingMethods
+ foldBag, bagToList, Bag
)
-import Class ( classBigSig, classTyCon, Class )
-import Id ( idType, replacePragmaInfo,
- isNullaryDataCon, dataConArgTys, Id )
-import ListSetOps ( minusList )
-import Maybes ( maybeToBool, expectJust, seqMaybe, catMaybes )
-import Name ( nameOccName, getSrcLoc, mkLocalName,
+import CmdLineOpts ( opt_GlasgowExts, opt_WarnMissingMethods )
+import Class ( classBigSig, Class )
+import Id ( idType, isNullaryDataCon, dataConArgTys, Id )
+import Maybes ( maybeToBool, seqMaybe, catMaybes )
+import Name ( nameOccName, mkLocalName,
isLocallyDefined, Module,
NamedThing(..)
)
import PrelVals ( nO_METHOD_BINDING_ERROR_ID )
import PprType ( pprParendGenType, pprConstraint )
import SrcLoc ( SrcLoc, noSrcLoc )
-import TyCon ( tyConDataCons, isSynTyCon, isDataTyCon, tyConDerivings )
-import Type ( Type, ThetaType, mkTyVarTys, isUnpointedType,
- splitSigmaTy, splitAppTys, isTyVarTy, matchTy, mkSigmaTy,
- splitTyConApp_maybe, getTyVar, splitDictTy_maybe,
- splitAlgTyConApp_maybe, splitRhoTy, isSynTy,
+import TyCon ( isSynTyCon, isDataTyCon, tyConDerivings )
+import Type ( Type, ThetaType, isUnpointedType,
+ splitSigmaTy, isTyVarTy, mkSigmaTy,
+ splitTyConApp_maybe, splitDictTy_maybe,
+ splitAlgTyConApp_maybe, splitRhoTy,
tyVarsOfTypes
)
import TyVar ( zipTyVarEnv, mkTyVarSet, tyVarSetToList, TyVar )
import TysPrim ( byteArrayPrimTyCon, mutableByteArrayPrimTyCon )
import TysWiredIn ( stringTy )
import Unique ( Unique, cCallableClassKey, cReturnableClassKey, Uniquable(..) )
-import Util ( zipEqual, removeDups )
import Outputable
\end{code}
#include "HsVersions.h"
-import RnHsSyn ( RenamedMonoBinds, RenamedSig(..),
- RenamedInstancePragmas(..) )
+import RnHsSyn ( RenamedMonoBinds, RenamedSig(..) )
import TcMonad
import Inst ( InstanceMapper )
import Maybes ( MaybeErr(..), mkLookupFunDef )
import Name ( getSrcLoc, Name )
import SrcLoc ( SrcLoc )
-import Type ( mkSigmaTy, mkForAllTys, mkDictTy, mkTyVarTys, instantiateThetaTy,
+import Type ( mkSigmaTy, mkDictTy, instantiateThetaTy,
ThetaType, Type
)
import PprType ( pprConstraint )
import TyCon ( tyConDataCons )
import TyVar ( TyVar, zipTyVarEnv )
import Unique ( Unique )
-import Util ( equivClasses, zipWithEqual, panic{-, pprTrace-}, assertPanic )
+import Util ( equivClasses, panic, assertPanic )
import Outputable
\end{code}
import Kind
import TcMonad
-import Unique ( Unique, pprUnique10 )
+import Unique ( Unique )
import Util ( nOfThem, panic )
import Outputable
\end{code}
import {-# SOURCE #-} TcGRHSs ( tcGRHSsAndBinds )
import HsSyn ( HsBinds(..), Match(..), GRHSsAndBinds(..), GRHS(..),
- HsExpr(..), MonoBinds(..),
+ HsExpr, MonoBinds(..),
collectPatBinders, pprMatch, getMatchLoc
)
import RnHsSyn ( RenamedMatch )
import TcPat ( tcPat )
import TcType ( TcType, TcMaybe, zonkTcType, newTyVarTy )
import TcSimplify ( bindInstsOfLocalFuns )
-import Unify ( unifyTauTy, unifyTauTyList, unifyFunTy )
+import Unify ( unifyTauTy, unifyFunTy )
import Name ( Name {- instance Outputable -} )
import Kind ( Kind, mkTypeKind )
import BasicTypes ( RecFlag(..) )
-import Type ( isTyVarTy, isTauTy, mkFunTy, splitFunTy_maybe )
+import Type ( isTauTy, mkFunTy )
import Util
import Outputable
import SrcLoc (SrcLoc)
import TcEnv ( TcIdOcc(..), tcExtendGlobalValEnv, tcExtendTyConEnv, getEnv_LocalIds,
getEnv_TyCons, getEnv_Classes, tcLookupLocalValue,
tcLookupLocalValueByKey, tcLookupTyCon,
- tcLookupGlobalValueByKeyMaybe )
+ tcLookupGlobalValueByKeyMaybe, initEnv )
import TcExpr ( tcId )
import TcIfaceSig ( tcInterfaceSigs )
import TcInstDcls ( tcInstDecls1, tcInstDecls2 )
typecheckModule us rn_name_supply mod
= let
- (maybe_result, warns, errs) = initTc us (tcModule rn_name_supply mod)
+ (maybe_result, warns, errs) =
+ initTc us initEnv (tcModule rn_name_supply mod)
in
print_errs warns >>
print_errs errs >>
#include "HsVersions.h"
-import {-# SOURCE #-} TcEnv ( TcEnv, initEnv )
-import {-# SOURCE #-} TcType ( TcMaybe, TcTyVarSet )
+import {-# SOURCE #-} TcEnv ( TcEnv )
import Type ( Type, GenType )
-import TyVar ( TyVar, GenTyVar )
import ErrUtils ( addShortErrLocLine, addShortWarnLocLine, ErrMsg, Message, WarnMsg )
-import CmdLineOpts ( opt_PprStyle_All, opt_PprUserLength )
+import CmdLineOpts ( opt_PprStyle_All )
import SST
import Bag ( Bag, emptyBag, isEmptyBag,
foldBag, unitBag, unionBags, snocBag )
-import FiniteMap ( FiniteMap, emptyFM, isEmptyFM{-, keysFM ToDo:rm-} )
-import Maybes ( MaybeErr(..) )
import SrcLoc ( SrcLoc, noSrcLoc )
import UniqFM ( UniqFM, emptyUFM )
import UniqSupply ( UniqSupply, getUnique, getUniques, splitUniqSupply,
-- With a builtin polymorphic type for runSST the type for
-- initTc should use TcM s r instead of TcM RealWorld r
+-- initEnv is passed in to avoid module recursion between TcEnv & TcMonad.
+
initTc :: UniqSupply
+ -> (TcRef RealWorld (UniqFM a) -> TcEnv RealWorld)
-> TcM RealWorld r
-> (Maybe r, Bag WarnMsg, Bag ErrMsg)
-initTc us do_this
+initTc us initenv do_this
= runSST (
newMutVarSST us `thenSST` \ us_var ->
newMutVarSST (emptyBag,emptyBag) `thenSST` \ errs_var ->
init_down = TcDown [] us_var
noSrcLoc
[] errs_var
- init_env = initEnv tvs_var
+ init_env = initenv tvs_var
in
recoverSST
(\_ -> returnSST Nothing)
= hsep [ ppr name, ptext SLIT("should have"),
n_arguments <> comma, text "but has been given", int m, char '.']
where
- errmsg = kind ++ " has too " ++ quantity ++ " arguments"
- quantity | m < n = "few"
- | otherwise = "many"
n_arguments | n == 0 = ptext SLIT("no arguments")
| n == 1 = ptext SLIT("1 argument")
| True = hsep [int n, ptext SLIT("arguments")]
kindToTcKind, tcDefaultKind
)
import Type ( Type, ThetaType,
- mkTyVarTy, mkFunTy, mkAppTy, mkSynTy,
+ mkTyVarTy, mkFunTy, mkSynTy,
mkSigmaTy, mkDictTy, mkTyConApp, mkAppTys
)
import TyVar ( TyVar, mkTyVar )
import TcMonad
import Inst ( lookupInst, lookupSimpleInst, LookupInstResult(..),
tyVarsOfInst,
- isTyVarDict, isDict, isStdClassTyVarDict, isMethodFor,
+ isDict, isStdClassTyVarDict, isMethodFor,
instToId, instBindingRequired, instCanBeGeneralised,
newDictFromOld,
instLoc, getDictClassTys,
pprInst, zonkInst,
Inst(..), LIE, pprInsts, pprInstsInFull, mkLIE,
- InstOrigin(..), pprOrigin
+ InstOrigin, pprOrigin
)
-import TcEnv ( TcIdOcc(..), tcGetGlobalTyVars )
-import TcType ( TcType, TcTyVar, TcTyVarSet, TcMaybe, tcInstType, tcInstTheta )
+import TcEnv ( TcIdOcc(..) )
+import TcType ( TcType, TcTyVarSet, TcMaybe, tcInstType, tcInstTheta )
import Unify ( unifyTauTy )
import Id ( mkIdSet )
-import Bag ( Bag, unitBag, listToBag, foldBag, filterBag, emptyBag, bagToList,
- snocBag, consBag, unionBags, isEmptyBag )
+import Bag ( Bag, bagToList, snocBag )
import Class ( Class, ClassInstEnv, classBigSig, classInstEnv )
import PrelInfo ( isNumericClass, isCcallishClass )
-import Maybes ( expectJust, firstJust, catMaybes, seqMaybe, maybeToBool )
+import Maybes ( maybeToBool )
import Type ( Type, ThetaType, TauType, mkTyVarTy, getTyVar,
- isTyVarTy, getTyVar_maybe, instantiateThetaTy
+ isTyVarTy, instantiateThetaTy
)
import PprType ( pprConstraint )
-import TysWiredIn ( intTy, unitTy )
-import TyVar ( elementOfTyVarSet, emptyTyVarSet, unionTyVarSets,
- intersectTyVarSets, unionManyTyVarSets,
- isEmptyTyVarSet, tyVarSetToList,
- zipTyVarEnv, emptyTyVarEnv
+import TysWiredIn ( unitTy )
+import TyVar ( intersectTyVarSets, unionManyTyVarSets,
+ isEmptyTyVarSet, zipTyVarEnv, emptyTyVarEnv
)
import FiniteMap
import BasicTypes ( TopLevelFlag(..) )
+++ /dev/null
-_interface_ TcType 1
-_exports_
-TcType TcMaybe TcTyVarSet;
-_declarations_
-1 data TcMaybe a;
-1 type TcTyVarSet a = TyVar.GenTyVarSet (ArrBase.MutableVar a (TcMaybe a));
+%
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+%
+\section[TcType]{Types used in the typechecker}
+
\begin{code}
module TcType (
-- friends:
-import Type ( Type, ThetaType, GenType(..), mkAppTy,
- tyVarsOfTypes, getTyVar_maybe, splitDictTy_maybe,
- splitForAllTys, splitRhoTy, isTyVarTy,
- mkForAllTys, instantiateTy
- )
-import TyVar ( TyVar, GenTyVar(..), TyVarSet, GenTyVarSet,
- TyVarEnv, lookupTyVarEnv, addToTyVarEnv,
- emptyTyVarEnv, mkTyVarEnv, zipTyVarEnv,
- tyVarSetToList
- )
+import Type ( Type, ThetaType, GenType(..), mkAppTy,
+ tyVarsOfTypes, splitDictTy_maybe,
+ isTyVarTy, instantiateTy
+ )
+import TyVar ( TyVar, GenTyVar(..), GenTyVarSet,
+ TyVarEnv, lookupTyVarEnv, addToTyVarEnv,
+ emptyTyVarEnv, zipTyVarEnv, tyVarSetToList
+ )
-- others:
-import Class ( Class )
-import TyCon ( isFunTyCon )
-import Kind ( Kind )
-import TcKind ( TcKind )
+import Class ( Class )
+import TyCon ( isFunTyCon )
+import Kind ( Kind )
import TcMonad
import TysPrim ( voidTy )
-import Name ( NamedThing(..) )
import Unique ( Unique )
import UniqFM ( UniqFM )
-import Maybes ( assocMaybe )
import BasicTypes ( unused )
-import Util ( zipEqual, nOfThem )
-import Outputable
+import Util ( nOfThem, panic )
\end{code}
-- friends:
import TcMonad
import Type ( GenType(..), Type, tyVarsOfType,
- typeKind, mkFunTy, splitFunTy_maybe, splitAppTys, splitTyConApp_maybe )
+ typeKind, mkFunTy, splitFunTy_maybe, splitTyConApp_maybe )
import TyCon ( TyCon, mkFunTyCon, isTupleTyCon, tyConArity, Arity )
import TyVar ( GenTyVar(..), TyVar, tyVarKind, tyVarSetToList,
TyVarEnv, lookupTyVarEnv, emptyTyVarEnv, addToTyVarEnv
= hang (ptext SLIT("Couldn't match the type"))
4 (sep [quotes (ppr ty1), ptext SLIT("against"), quotes (ppr ty2)])
-expectedFunErr ty
- = hang (text "Function type expected, but found the type")
- 4 (ppr ty)
-
unifyKindErr tyvar ty
= hang (ptext SLIT("Compiler bug: kind mis-match between"))
4 (sep [quotes (hsep [ppr tyvar, ptext SLIT("::"), ppr (tyVarKind tyvar)]),