[project @ 1998-02-03 17:11:28 by simonm]

- 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'.

diff --git a/ghc/compiler/typecheck/Inst.lhs b/ghc/compiler/typecheck/Inst.lhs
index 64f831a..6ff359b 100644 (file)
--- a/ghc/compiler/typecheck/Inst.lhs
+++ b/ghc/compiler/typecheck/Inst.lhs
@@ -29,20 +29,19 @@ module Inst (
 
 #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 
@@ -51,14 +50,13 @@ import Id   ( idType, mkUserLocal, mkSysLocal, Id,
                  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 )
@@ -68,7 +66,7 @@ import Unique ( fromRationalClassOpKey, rationalTyConKey,
                  fromIntClassOpKey, fromIntegerClassOpKey, Unique
                )
 import Maybes  ( MaybeErr, expectJust )
-import Util    ( thenCmp, zipEqual, zipWithEqual, isIn )
+import Util    ( thenCmp, zipWithEqual )
 import Outputable
 \end{code}
 

diff --git a/ghc/compiler/typecheck/TcBinds.lhs b/ghc/compiler/typecheck/TcBinds.lhs
index 43612e7..3889258 100644 (file)
--- a/ghc/compiler/typecheck/TcBinds.lhs
+++ b/ghc/compiler/typecheck/TcBinds.lhs
@@ -19,7 +19,7 @@ import RnHsSyn                ( RenamedHsBinds, RenamedSig(..),
                          RenamedMonoBinds
                        )
 import TcHsSyn         ( TcHsBinds, TcMonoBinds,
-                         TcExpr, TcIdOcc(..), TcIdBndr, 
+                         TcIdOcc(..), TcIdBndr, 
                          tcIdType
                        )
 
@@ -38,7 +38,7 @@ import TcPat          ( tcPat )
 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 )
@@ -46,16 +46,16 @@ 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 )

diff --git a/ghc/compiler/typecheck/TcClassDcl.lhs b/ghc/compiler/typecheck/TcClassDcl.lhs
index 407f3d6..818842c 100644 (file)
--- a/ghc/compiler/typecheck/TcClassDcl.lhs
+++ b/ghc/compiler/typecheck/TcClassDcl.lhs
@@ -9,21 +9,18 @@ module TcClassDcl ( tcClassDecl1, tcClassDecls2, tcMethodBind, badMethodErr ) wh
 #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(..) )
@@ -36,9 +33,9 @@ import TcType         ( TcType, TcTyVar, TcTyVarSet, tcInstSigTyVars,
                        )
 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, 
@@ -46,16 +43,13 @@ import Id           ( Id, StrictnessMark(..),
                        )
 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(..) )

diff --git a/ghc/compiler/typecheck/TcDefaults.lhs b/ghc/compiler/typecheck/TcDefaults.lhs
index 714f278..f6e337e 100644 (file)
--- a/ghc/compiler/typecheck/TcDefaults.lhs
+++ b/ghc/compiler/typecheck/TcDefaults.lhs
@@ -9,15 +9,14 @@ module TcDefaults ( tcDefaults ) where
 #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 )

diff --git a/ghc/compiler/typecheck/TcDeriv.lhs b/ghc/compiler/typecheck/TcDeriv.lhs
index 4e39253..631833b 100644 (file)
--- a/ghc/compiler/typecheck/TcDeriv.lhs
+++ b/ghc/compiler/typecheck/TcDeriv.lhs
@@ -11,13 +11,12 @@ module TcDeriv ( tcDeriving ) where
 #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 )
@@ -25,16 +24,16 @@ import TcSimplify   ( tcSimplifyThetas )
 
 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 )
@@ -48,12 +47,9 @@ import Type          ( GenType(..), TauType, mkTyVarTys, mkTyConApp,
                        )
 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}
 

diff --git a/ghc/compiler/typecheck/TcEnv.hi-boot b/ghc/compiler/typecheck/TcEnv.hi-boot
index 89ac412..62273d9 100644 (file)
--- a/ghc/compiler/typecheck/TcEnv.hi-boot
+++ b/ghc/compiler/typecheck/TcEnv.hi-boot
@@ -1,6 +1,5 @@
 _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 ;;

diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs
index a790a8b..587176a 100644 (file)
--- a/ghc/compiler/typecheck/TcEnv.lhs
+++ b/ghc/compiler/typecheck/TcEnv.lhs
@@ -24,14 +24,13 @@ module TcEnv(
 
 #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 )
@@ -40,14 +39,13 @@ import Class        ( Class )
 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}

diff --git a/ghc/compiler/typecheck/TcExpr.lhs b/ghc/compiler/typecheck/TcExpr.lhs
index 38a124e..44964cf 100644 (file)
--- a/ghc/compiler/typecheck/TcExpr.lhs
+++ b/ghc/compiler/typecheck/TcExpr.lhs
@@ -10,7 +10,7 @@ module TcExpr ( tcExpr, tcStmt, tcId ) where
 
 import HsSyn           ( HsExpr(..), HsLit(..), ArithSeqInfo(..), 
                          HsBinds(..), Stmt(..), DoOrListComp(..),
-                         pprParendExpr, failureFreePat, collectPatBinders
+                         failureFreePat, collectPatBinders
                        )
 import RnHsSyn         ( RenamedHsExpr, 
                          RenamedStmt, RenamedRecordBinds
@@ -29,7 +29,7 @@ import Inst           ( Inst, InstOrigin(..), OverloadedLit(..),
 import TcBinds         ( tcBindsAndThen, checkSigTyVars, sigThetaCtxt )
 import TcEnv           ( TcIdOcc(..), tcInstId,
                          tcLookupLocalValue, tcLookupGlobalValue, tcLookupClassByKey,
-                         tcLookupGlobalValueByKey, newMonoIds, tcGetGlobalTyVars,
+                         tcLookupGlobalValueByKey, newMonoIds,
                          tcExtendGlobalTyVars, tcLookupGlobalValueMaybe,
                          tcLookupTyCon
                        )
@@ -40,7 +40,7 @@ import TcSimplify     ( tcSimplifyAndCheck )
 import TcType          ( TcType, TcMaybe(..),
                          tcInstType, tcInstSigTcType, tcInstTyVars,
                          tcInstSigType, tcInstTcType, tcInstTheta, tcSplitRhoTy,
-                         newTyVarTy, newTyVarTys, zonkTcTyVars, zonkTcType )
+                         newTyVarTy, newTyVarTys, zonkTcType )
 import TcKind          ( TcKind )
 
 import Class           ( Class )
@@ -51,27 +51,23 @@ import Id           ( idType, dataConFieldLabels, dataConSig, recordSelectorFieldLabel,
                        )
 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,

diff --git a/ghc/compiler/typecheck/TcGRHSs.lhs b/ghc/compiler/typecheck/TcGRHSs.lhs
index 77a0eab..d19715c 100644 (file)
--- a/ghc/compiler/typecheck/TcGRHSs.lhs
+++ b/ghc/compiler/typecheck/TcGRHSs.lhs
@@ -16,10 +16,7 @@ import TcMonad
 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}

diff --git a/ghc/compiler/typecheck/TcIfaceSig.lhs b/ghc/compiler/typecheck/TcIfaceSig.lhs
index 7d7ca67..2d7a666 100644 (file)
--- a/ghc/compiler/typecheck/TcIfaceSig.lhs
+++ b/ghc/compiler/typecheck/TcIfaceSig.lhs
@@ -11,8 +11,8 @@ module TcIfaceSig ( tcInterfaceSigs ) where
 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 )

diff --git a/ghc/compiler/typecheck/TcInstDcls.lhs b/ghc/compiler/typecheck/TcInstDcls.lhs
index 900d97f..32a9c3a 100644 (file)
--- a/ghc/compiler/typecheck/TcInstDcls.lhs
+++ b/ghc/compiler/typecheck/TcInstDcls.lhs
@@ -11,77 +11,62 @@ module TcInstDcls (
 
 #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}
 

diff --git a/ghc/compiler/typecheck/TcInstUtil.lhs b/ghc/compiler/typecheck/TcInstUtil.lhs
index a12633a..28abdaf 100644 (file)
--- a/ghc/compiler/typecheck/TcInstUtil.lhs
+++ b/ghc/compiler/typecheck/TcInstUtil.lhs
@@ -15,8 +15,7 @@ module TcInstUtil (
 
 #include "HsVersions.h"
 
-import RnHsSyn         ( RenamedMonoBinds, RenamedSig(..), 
-                         RenamedInstancePragmas(..) )
+import RnHsSyn         ( RenamedMonoBinds, RenamedSig(..) )
 
 import TcMonad
 import Inst            ( InstanceMapper )
@@ -28,7 +27,7 @@ import SpecEnv                ( emptySpecEnv, addToSpecEnv )
 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 )
@@ -36,7 +35,7 @@ import Class          ( classTyCon )
 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}
 

diff --git a/ghc/compiler/typecheck/TcKind.lhs b/ghc/compiler/typecheck/TcKind.lhs
index 1429bbd..d886393 100644 (file)
--- a/ghc/compiler/typecheck/TcKind.lhs
+++ b/ghc/compiler/typecheck/TcKind.lhs
@@ -20,7 +20,7 @@ module TcKind (
 import Kind
 import TcMonad
 
-import Unique  ( Unique, pprUnique10 )
+import Unique  ( Unique )
 import Util    ( nOfThem, panic )
 import Outputable
 \end{code}

diff --git a/ghc/compiler/typecheck/TcMatches.lhs b/ghc/compiler/typecheck/TcMatches.lhs
index 9185d60..6ea887e 100644 (file)
--- a/ghc/compiler/typecheck/TcMatches.lhs
+++ b/ghc/compiler/typecheck/TcMatches.lhs
@@ -11,7 +11,7 @@ module TcMatches ( tcMatchesFun, tcMatchesCase, tcMatchExpected ) where
 import {-# SOURCE #-} TcGRHSs ( tcGRHSsAndBinds )
 
 import HsSyn           ( HsBinds(..), Match(..), GRHSsAndBinds(..), GRHS(..),
-                         HsExpr(..), MonoBinds(..),
+                         HsExpr, MonoBinds(..),
                          collectPatBinders, pprMatch, getMatchLoc
                        )
 import RnHsSyn         ( RenamedMatch )
@@ -23,12 +23,12 @@ import TcEnv                ( TcIdOcc(..), newMonoIds )
 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)

diff --git a/ghc/compiler/typecheck/TcModule.lhs b/ghc/compiler/typecheck/TcModule.lhs
index d216314..7a6cb15 100644 (file)
--- a/ghc/compiler/typecheck/TcModule.lhs
+++ b/ghc/compiler/typecheck/TcModule.lhs
@@ -28,7 +28,7 @@ import TcDefaults     ( tcDefaults )
 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 )
@@ -86,7 +86,8 @@ typecheckModule
 
 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    >>

diff --git a/ghc/compiler/typecheck/TcMonad.lhs b/ghc/compiler/typecheck/TcMonad.lhs
index ceb589f..02552da 100644 (file)
--- a/ghc/compiler/typecheck/TcMonad.lhs
+++ b/ghc/compiler/typecheck/TcMonad.lhs
@@ -34,19 +34,15 @@ module TcMonad(
 
 #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,
@@ -74,11 +70,14 @@ type TcM    s r =  TcDown s -> TcEnv s -> FSST s r ()
 -- 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 ->
@@ -87,7 +86,7 @@ initTc us do_this
           init_down = TcDown [] us_var
                             noSrcLoc
                             [] errs_var
-         init_env  = initEnv tvs_var
+         init_env  = initenv tvs_var
       in
       recoverSST
        (\_ -> returnSST Nothing)
@@ -559,9 +558,6 @@ arityErr kind name n m
   = 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")]

diff --git a/ghc/compiler/typecheck/TcMonoType.lhs b/ghc/compiler/typecheck/TcMonoType.lhs
index dad3e7b..aec75e7 100644 (file)
--- a/ghc/compiler/typecheck/TcMonoType.lhs
+++ b/ghc/compiler/typecheck/TcMonoType.lhs
@@ -18,7 +18,7 @@ import TcKind         ( TcKind, mkBoxedTypeKind, mkTypeKind, mkArrowKind,
                          kindToTcKind, tcDefaultKind
                        )
 import Type            ( Type, ThetaType, 
-                         mkTyVarTy, mkFunTy, mkAppTy, mkSynTy,
+                         mkTyVarTy, mkFunTy, mkSynTy,
                          mkSigmaTy, mkDictTy, mkTyConApp, mkAppTys
                        )
 import TyVar           ( TyVar, mkTyVar )

diff --git a/ghc/compiler/typecheck/TcSimplify.lhs b/ghc/compiler/typecheck/TcSimplify.lhs
index f38dc93..0de237d 100644 (file)
--- a/ghc/compiler/typecheck/TcSimplify.lhs
+++ b/ghc/compiler/typecheck/TcSimplify.lhs
@@ -131,34 +131,31 @@ import TcHsSyn            ( TcExpr, TcIdOcc(..), TcIdBndr,
 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(..) )

diff --git a/ghc/compiler/typecheck/TcType.hi-boot b/ghc/compiler/typecheck/TcType.hi-boot
deleted file mode 100644 (file)
index 49e5cd6..0000000
--- a/ghc/compiler/typecheck/TcType.hi-boot
+++ /dev/null
@@ -1,6 +0,0 @@
-_interface_ TcType 1
-_exports_
-TcType TcMaybe TcTyVarSet;
-_declarations_
-1 data TcMaybe a;
-1 type TcTyVarSet a = TyVar.GenTyVarSet (ArrBase.MutableVar a (TcMaybe a));

diff --git a/ghc/compiler/typecheck/TcType.lhs b/ghc/compiler/typecheck/TcType.lhs
index 2944d90..9cb4112 100644 (file)
--- a/ghc/compiler/typecheck/TcType.lhs
+++ b/ghc/compiler/typecheck/TcType.lhs
@@ -1,3 +1,8 @@
+%
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
+%
+\section[TcType]{Types used in the typechecker}
+
 \begin{code}
 module TcType (
   
@@ -36,33 +41,27 @@ 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}
 
 

diff --git a/ghc/compiler/typecheck/Unify.lhs b/ghc/compiler/typecheck/Unify.lhs
index 439ccda..077aed6 100644 (file)
--- a/ghc/compiler/typecheck/Unify.lhs
+++ b/ghc/compiler/typecheck/Unify.lhs
@@ -17,7 +17,7 @@ module Unify ( unifyTauTy, unifyTauTyList, unifyTauTyLists,
 -- 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
@@ -481,10 +481,6 @@ unifyMisMatch ty1 ty2
   = 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)]),