From: simonm <unknown>
Date: Tue, 3 Feb 1998 17:11:58 +0000 (+0000)
Subject: [project @ 1998-02-03 17:11:28 by simonm]
X-Git-Tag: Approx_2487_patches~1005
X-Git-Url: http://git.megacz.com/?a=commitdiff_plain;h=c29022c49449b7d8862dcc2259e16cafe9461945;p=ghc-hetmet.git

[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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
--- 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
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
--- 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
--- 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)]),