[project @ 2003-09-20 17:26:46 by ross]
[ghc-hetmet.git] / ghc / compiler / typecheck / TcBinds.lhs
index 75b3683..b5d2cb7 100644 (file)
@@ -1,66 +1,55 @@
 %
 %
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
 %
 \section[TcBinds]{TcBinds}
 
 \begin{code}
 %
 \section[TcBinds]{TcBinds}
 
 \begin{code}
-#include "HsVersions.h"
-
-module TcBinds ( tcBindsAndThen, tcPragmaSigs, checkSigTyVars ) where
+module TcBinds ( tcBindsAndThen, tcTopBinds, tcMonoBinds, tcSpecSigs ) where
 
 
-IMP_Ubiq()
+#include "HsVersions.h"
 
 
-import HsSyn           ( HsBinds(..), Bind(..), Sig(..), MonoBinds(..), 
-                         Match, HsType, InPat(..), OutPat(..), HsExpr(..),
-                         GRHSsAndBinds, ArithSeqInfo, HsLit, Fake, Stmt, DoOrListComp, Fixity, 
-                         collectBinders )
-import RnHsSyn         ( SYN_IE(RenamedHsBinds), SYN_IE(RenamedBind), RenamedSig(..), 
-                         SYN_IE(RenamedMonoBinds)
-                       )
-import TcHsSyn         ( SYN_IE(TcHsBinds), SYN_IE(TcBind), SYN_IE(TcMonoBinds),
-                         TcIdOcc(..), SYN_IE(TcIdBndr), SYN_IE(TcExpr), 
-                         tcIdType
-                       )
+import {-# SOURCE #-} TcMatches ( tcGRHSsPat, tcMatchesFun )
+import {-# SOURCE #-} TcExpr  ( tcCheckSigma, tcCheckRho )
 
 
-import TcMonad
-import Inst            ( Inst, SYN_IE(LIE), emptyLIE, plusLIE, InstOrigin(..),
-                         newDicts, tyVarsOfInst, instToId
+import CmdLineOpts     ( DynFlag(Opt_NoMonomorphismRestriction) )
+import HsSyn           ( HsExpr(..), HsBinds(..), MonoBinds(..), Sig(..), 
+                         Match(..), mkMonoBind,
+                         collectMonoBinders, andMonoBinds,
+                         collectSigTysFromMonoBinds
                        )
                        )
-import TcEnv           ( tcExtendLocalValEnv, tcLookupLocalValueOK, newMonoIds,
-                         tcGetGlobalTyVars, tcExtendGlobalTyVars
+import RnHsSyn         ( RenamedHsBinds, RenamedSig, RenamedMonoBinds )
+import TcHsSyn         ( TcHsBinds, TcMonoBinds, TcId, zonkId, mkHsLet )
+
+import TcRnMonad
+import Inst            ( InstOrigin(..), newDicts, newIPDict, instToId )
+import TcEnv           ( tcExtendLocalValEnv, tcExtendLocalValEnv2, newLocalName )
+import TcUnify         ( Expected(..), newHole, unifyTauTyLists, checkSigTyVarsWrt, sigCtxt )
+import TcSimplify      ( tcSimplifyInfer, tcSimplifyInferCheck, tcSimplifyRestricted, 
+                         tcSimplifyToDicts, tcSimplifyIPs )
+import TcMonoType      ( tcHsSigType, UserTypeCtxt(..), TcSigInfo(..), 
+                         tcTySig, maybeSig, tcSigPolyId, tcSigMonoId, tcAddScopedTyVars
                        )
                        )
-import SpecEnv         ( SpecEnv )
-IMPORT_DELOOPER(TcLoop)                ( tcGRHSsAndBinds )
-import TcMatches       ( tcMatchesFun )
-import TcSimplify      ( tcSimplify, tcSimplifyAndCheck )
-import TcMonoType      ( tcHsType )
-import TcPat           ( tcPat )
+import TcPat           ( tcPat, tcSubPat, tcMonoPatBndr )
 import TcSimplify      ( bindInstsOfLocalFuns )
 import TcSimplify      ( bindInstsOfLocalFuns )
-import TcType          ( SYN_IE(TcType), SYN_IE(TcThetaType), SYN_IE(TcTauType), 
-                         SYN_IE(TcTyVarSet), SYN_IE(TcTyVar),
-                         newTyVarTy, zonkTcType, zonkTcTyVar, zonkTcTyVars,
-                         newTcTyVar, tcInstSigType, newTyVarTys
+import TcMType         ( newTyVar, newTyVarTy, zonkTcTyVarToTyVar )
+import TcType          ( TcTyVar, mkTyVarTy, mkForAllTys, mkFunTys, tyVarsOfType, 
+                         mkPredTy, mkForAllTy, isUnLiftedType, 
+                         unliftedTypeKind, liftedTypeKind, openTypeKind, eqKind
                        )
                        )
-import Unify           ( unifyTauTy )
-
-import Kind            ( isUnboxedTypeKind, mkTypeKind, isTypeKind, mkBoxedTypeKind )
-import Id              ( GenId, idType, mkUserLocal, mkUserId )
-import IdInfo          ( noIdInfo )
-import Maybes          ( assocMaybe, catMaybes )
-import Name            ( pprNonSym, getOccName, getSrcLoc, Name )
-import PragmaInfo      ( PragmaInfo(..) )
-import Pretty
-import Type            ( mkTyVarTy, mkTyVarTys, isTyVarTy, tyVarsOfTypes, eqSimpleTheta, 
-                         mkSigmaTy, splitSigmaTy, mkForAllTys, mkFunTys, getTyVar, 
-                         splitRhoTy, mkForAllTy, splitForAllTy )
-import TyVar           ( GenTyVar, SYN_IE(TyVar), tyVarKind, minusTyVarSet, emptyTyVarSet,
-                         elementOfTyVarSet, unionTyVarSets, tyVarSetToList )
-import Bag             ( bagToList, foldrBag, isEmptyBag )
-import Util            ( isIn, zipEqual, zipWithEqual, zipWith3Equal, hasNoDups, assoc,
-                         assertPanic, panic )
-import PprType         ( GenClass, GenType, GenTyVar )
-import Unique          ( Unique )
-import Outputable      ( interppSP, interpp'SP )
+
+import CoreFVs         ( idFreeTyVars )
+import Id              ( mkLocalId, mkSpecPragmaId, setInlinePragma )
+import Var             ( idType, idName )
+import Name            ( Name, getSrcLoc )
+import NameSet
+import Var             ( tyVarKind )
+import VarSet
+import Bag
+import Util            ( isIn, equalLength )
+import BasicTypes      ( TopLevelFlag(..), RecFlag(..), isNonRec, isRec, 
+                         isNotTopLevel, isAlwaysActive )
+import FiniteMap       ( listToFM, lookupFM )
+import Outputable
 \end{code}
 
 
 \end{code}
 
 
@@ -96,251 +85,471 @@ At the top-level the LIE is sure to contain nothing but constant
 dictionaries, which we resolve at the module level.
 
 \begin{code}
 dictionaries, which we resolve at the module level.
 
 \begin{code}
-tcBindsAndThen
-       :: (TcHsBinds s -> thing -> thing)              -- Combinator
-       -> RenamedHsBinds
-       -> TcM s (thing, LIE s, thing_ty)
-       -> TcM s (thing, LIE s, thing_ty)
-
-tcBindsAndThen combiner EmptyBinds do_next
-  = do_next    `thenTc` \ (thing, lie, thing_ty) ->
-    returnTc (combiner EmptyBinds thing, lie, thing_ty)
+tcTopBinds :: RenamedHsBinds -> TcM (TcMonoBinds, TcLclEnv)
+       -- Note: returning the TcLclEnv is more than we really
+       --       want.  The bit we care about is the local bindings
+       --       and the free type variables thereof
+tcTopBinds binds
+  = tc_binds_and_then TopLevel glue binds      $
+    getLclEnv                                  `thenM` \ env ->
+    returnM (EmptyMonoBinds, env)
+  where
+       -- The top level bindings are flattened into a giant 
+       -- implicitly-mutually-recursive MonoBinds
+    glue binds1 (binds2, env) = (flatten binds1 `AndMonoBinds` binds2, env)
+    flatten EmptyBinds                 = EmptyMonoBinds
+    flatten (b1 `ThenBinds` b2) = flatten b1 `AndMonoBinds` flatten b2
+    flatten (MonoBind b _ _)   = b
+       -- Can't have a IPBinds at top level
 
 
-tcBindsAndThen combiner (SingleBind bind) do_next
-  = tcBindWithSigsAndThen combiner bind [] do_next
 
 
-tcBindsAndThen combiner (BindWith bind sigs) do_next
-  = tcBindWithSigsAndThen combiner bind sigs do_next
+tcBindsAndThen
+       :: (TcHsBinds -> thing -> thing)                -- Combinator
+       -> RenamedHsBinds
+       -> TcM thing
+       -> TcM thing
 
 
-tcBindsAndThen combiner (ThenBinds binds1 binds2) do_next
-  = tcBindsAndThen combiner binds1 (tcBindsAndThen combiner binds2 do_next)
-\end{code}
+tcBindsAndThen = tc_binds_and_then NotTopLevel
 
 
-An aside.  The original version of @tcBindsAndThen@ which lacks a
-combiner function, appears below.  Though it is perfectly well
-behaved, it cannot be typed by Haskell, because the recursive call is
-at a different type to the definition itself.  There aren't too many
-examples of this, which is why I thought it worth preserving! [SLPJ]
+tc_binds_and_then top_lvl combiner EmptyBinds do_next
+  = do_next
+tc_binds_and_then top_lvl combiner (MonoBind EmptyMonoBinds sigs is_rec) do_next
+  = do_next
 
 
-\begin{pseudocode}
-tcBindsAndThen
-       :: RenamedHsBinds
-       -> TcM s (thing, LIE s, thing_ty))
-       -> TcM s ((TcHsBinds s, thing), LIE s, thing_ty)
+tc_binds_and_then top_lvl combiner (ThenBinds b1 b2) do_next
+  = tc_binds_and_then top_lvl combiner b1      $
+    tc_binds_and_then top_lvl combiner b2      $
+    do_next
 
 
-tcBindsAndThen EmptyBinds do_next
-  = do_next            `thenTc` \ (thing, lie, thing_ty) ->
-    returnTc ((EmptyBinds, thing), lie, thing_ty)
+tc_binds_and_then top_lvl combiner (IPBinds binds is_with) do_next
+  = getLIE do_next                     `thenM` \ (result, expr_lie) ->
+    mapAndUnzipM tc_ip_bind binds      `thenM` \ (avail_ips, binds') ->
 
 
-tcBindsAndThen (SingleBind bind) do_next
-  = tcBindAndThen bind [] do_next
+       -- If the binding binds ?x = E, we  must now 
+       -- discharge any ?x constraints in expr_lie
+    tcSimplifyIPs avail_ips expr_lie   `thenM` \ dict_binds ->
 
 
-tcBindsAndThen (BindWith bind sigs) do_next
-  = tcBindAndThen bind sigs do_next
+    returnM (combiner (IPBinds binds' is_with) $
+            combiner (mkMonoBind Recursive dict_binds) result)
+  where
+       -- I wonder if we should do these one at at time
+       -- Consider     ?x = 4
+       --              ?y = ?x + 1
+    tc_ip_bind (ip, expr)
+      = newTyVarTy openTypeKind                `thenM` \ ty ->
+       getSrcLocM                      `thenM` \ loc ->
+       newIPDict (IPBind ip) ip ty     `thenM` \ (ip', ip_inst) ->
+       tcCheckRho expr ty              `thenM` \ expr' ->
+       returnM (ip_inst, (ip', expr'))
+
+tc_binds_and_then top_lvl combiner (MonoBind bind sigs is_rec) do_next
+  =    -- BRING ANY SCOPED TYPE VARIABLES INTO SCOPE
+       -- Notice that they scope over 
+       --      a) the type signatures in the binding group
+       --      b) the bindings in the group
+       --      c) the scope of the binding group (the "in" part)
+      tcAddScopedTyVars (collectSigTysFromMonoBinds bind)      $
+
+      tcBindWithSigs top_lvl bind sigs is_rec  `thenM` \ (poly_binds, poly_ids) ->
+  
+      case top_lvl of
+       TopLevel        -- For the top level don't bother will all this
+                       --  bindInstsOfLocalFuns stuff. All the top level 
+                       -- things are rec'd together anyway, so it's fine to
+                       -- leave them to the tcSimplifyTop, and quite a bit faster too
+                       --
+                       -- Subtle (and ugly) point: furthermore at top level we
+                       -- return the TcLclEnv, which contains the LIE var; we
+                       -- don't want to return the wrong one!
+               -> tc_body poly_ids                     `thenM` \ (prag_binds, thing) ->
+                  returnM (combiner (mkMonoBind Recursive (poly_binds `andMonoBinds` prag_binds)) 
+                                    thing)
+
+       NotTopLevel     -- For nested bindings we must do teh bindInstsOfLocalFuns thing
+               -> getLIE (tc_body poly_ids)            `thenM` \ ((prag_binds, thing), lie) ->
+
+                       -- Create specialisations of functions bound here
+                   bindInstsOfLocalFuns lie poly_ids   `thenM` \ lie_binds ->
+
+                       -- We want to keep non-recursive things non-recursive
+                       -- so that we desugar unlifted bindings correctly
+                  if isRec is_rec then
+                    returnM (
+                       combiner (mkMonoBind Recursive (
+                               poly_binds `andMonoBinds`
+                               lie_binds  `andMonoBinds`
+                               prag_binds)) thing
+                    )
+                  else
+                    returnM (
+                       combiner (mkMonoBind NonRecursive poly_binds) $
+                       combiner (mkMonoBind NonRecursive prag_binds) $
+                       combiner (mkMonoBind Recursive lie_binds)     $
+                               -- NB: the binds returned by tcSimplify and bindInstsOfLocalFuns
+                               -- aren't guaranteed in dependency order (though we could change
+                               -- that); hence the Recursive marker.
+                       thing)
+  where
+    tc_body poly_ids   -- Type check the pragmas and "thing inside"
+      =   -- Extend the environment to bind the new polymorphic Ids
+         tcExtendLocalValEnv poly_ids  $
+  
+         -- Build bindings and IdInfos corresponding to user pragmas
+         tcSpecSigs sigs               `thenM` \ prag_binds ->
 
 
-tcBindsAndThen (ThenBinds binds1 binds2) do_next
-  = tcBindsAndThen binds1 (tcBindsAndThen binds2 do_next)
-       `thenTc` \ ((binds1', (binds2', thing')), lie1, thing_ty) ->
+         -- Now do whatever happens next, in the augmented envt
+         do_next                       `thenM` \ thing ->
 
 
-    returnTc ((binds1' `ThenBinds` binds2', thing'), lie1, thing_ty)
-\end{pseudocode}
+         returnM (prag_binds, thing)
+\end{code}
 
 
 %************************************************************************
 %*                                                                     *
 
 
 %************************************************************************
 %*                                                                     *
-\subsection{tcBindWithSigsAndThen}
+\subsection{tcBindWithSigs}
 %*                                                                     *
 %************************************************************************
 
 %*                                                                     *
 %************************************************************************
 
-@tcBindAndThen@ deals with one binding group and the thing it scopes over.
+@tcBindWithSigs@ deals with a single binding group.  It does generalisation,
+so all the clever stuff is in here.
+
+* binder_names and mbind must define the same set of Names
+
+* The Names in tc_ty_sigs must be a subset of binder_names
+
+* The Ids in tc_ty_sigs don't necessarily have to have the same name
+  as the Name in the tc_ty_sig
 
 \begin{code}
 
 \begin{code}
-tcBindWithSigsAndThen
-       :: (TcHsBinds s -> thing -> thing)                -- Combinator
-       -> RenamedBind                                    -- The Bind to typecheck
-       -> [RenamedSig]                                   -- ...and its signatures
-       -> TcM s (thing, LIE s, thing_ty)                 -- Thing to type check in
-                                                         -- augmented envt
-       -> TcM s (thing, LIE s, thing_ty)                 -- Results, incl the
-
-tcBindWithSigsAndThen combiner bind sigs do_next
-  = 
-     recoverTc (
+tcBindWithSigs 
+       :: TopLevelFlag
+       -> RenamedMonoBinds
+       -> [RenamedSig]         -- Used solely to get INLINE, NOINLINE sigs
+       -> RecFlag
+       -> TcM (TcMonoBinds, [TcId])
+
+tcBindWithSigs top_lvl mbind sigs is_rec
+  =    -- TYPECHECK THE SIGNATURES
+     recoverM (returnM []) (
+       mappM tcTySig [sig | sig@(Sig name _ _) <- sigs]
+     )                                         `thenM` \ tc_ty_sigs ->
+
+       -- SET UP THE MAIN RECOVERY; take advantage of any type sigs
+   recoverM (
        -- If typechecking the binds fails, then return with each
        -- If typechecking the binds fails, then return with each
-       -- binder given type (forall a.a), to minimise subsequent
+       -- signature-less binder given type (forall a.a), to minimise subsequent
        -- error messages
        -- error messages
-       newTcTyVar mkBoxedTypeKind              `thenNF_Tc` \ alpha_tv ->
+       newTyVar liftedTypeKind         `thenM` \ alpha_tv ->
        let
        let
-         forall_a_a = mkForAllTy alpha_tv (mkTyVarTy alpha_tv)
-         poly_ids   = [ mkUserId name forall_a_a NoPragmaInfo
-                      | name <- binder_names]
+         forall_a_a    = mkForAllTy alpha_tv (mkTyVarTy alpha_tv)
+          binder_names  = collectMonoBinders mbind
+         poly_ids      = map mk_dummy binder_names
+         mk_dummy name = case maybeSig tc_ty_sigs name of
+                           Just sig -> tcSigPolyId sig                 -- Signature
+                           Nothing  -> mkLocalId name forall_a_a       -- No signature
        in
        in
-               -- Extend the environment to bind the new polymorphic Ids
-               -- and do the thing inside
-       tcExtendLocalValEnv binder_names poly_ids $
-       do_next
-    ) $
+       traceTc (text "tcBindsWithSigs: error recovery" <+> ppr binder_names)   `thenM_`
+       returnM (EmptyMonoBinds, poly_ids)
+    )                                          $
 
 
-    fixTc (\ ~(prag_info_fn, _) ->
-       -- This is the usual prag_info fix; the PragmaInfo field of an Id
-       -- is not inspected till ages later in the compiler, so there
-       -- should be no black-hole problems here.
-    tcBindWithSigs binder_names bind 
-                 sigs prag_info_fn     `thenTc` \ (poly_binds, poly_lie, poly_ids) ->
+       -- TYPECHECK THE BINDINGS
+    getLIE (tcMonoBinds mbind tc_ty_sigs is_rec)       `thenM` \ ((mbind', bndr_names_w_ids), lie_req) ->
+    let
+       (binder_names, mono_ids) = unzip (bagToList bndr_names_w_ids)
+       tau_tvs = foldr (unionVarSet . tyVarsOfType . idType) emptyVarSet mono_ids
+    in
 
 
-       -- Extend the environment to bind the new polymorphic Ids
-    tcExtendLocalValEnv binder_names poly_ids $
+       -- GENERALISE
+       --      (it seems a bit crude to have to do getLIE twice,
+       --       but I can't see a better way just now)
+    addSrcLoc  (minimum (map getSrcLoc binder_names))          $
+    addErrCtxt (genCtxt binder_names)                          $
+    getLIE (generalise binder_names mbind tau_tvs lie_req tc_ty_sigs)
+                       `thenM` \ ((tc_tyvars_to_gen, dict_binds, dict_ids), lie_free) ->
+
+
+       -- ZONK THE GENERALISED TYPE VARIABLES TO REAL TyVars
+       -- This commits any unbound kind variables to boxed kind, by unification
+       -- It's important that the final quanfified type variables
+       -- are fully zonked, *including boxity*, because they'll be 
+       -- included in the forall types of the polymorphic Ids.
+       -- At calls of these Ids we'll instantiate fresh type variables from
+       -- them, and we use their boxity then.
+    mappM zonkTcTyVarToTyVar tc_tyvars_to_gen  `thenM` \ real_tyvars_to_gen ->
+
+       -- ZONK THE Ids
+       -- It's important that the dict Ids are zonked, including the boxity set
+       -- in the previous step, because they are later used to form the type of 
+       -- the polymorphic thing, and forall-types must be zonked so far as 
+       -- their bound variables are concerned
+    mappM zonkId dict_ids                              `thenM` \ zonked_dict_ids ->
+    mappM zonkId mono_ids                              `thenM` \ zonked_mono_ids ->
+
+       -- BUILD THE POLYMORPHIC RESULT IDs
+    let
+       exports  = zipWith mk_export binder_names zonked_mono_ids
+       poly_ids = [poly_id | (_, poly_id, _) <- exports]
+       dict_tys = map idType zonked_dict_ids
+
+       inlines    = mkNameSet [name | InlineSig True name _ loc <- sigs]
+                       -- Any INLINE sig (regardless of phase control) 
+                       -- makes the RHS look small
+        inline_phases = listToFM [(name, phase) | InlineSig _ name phase _ <- sigs, 
+                                                 not (isAlwaysActive phase)]
+                       -- Set the IdInfo field to control the inline phase
+                       -- AlwaysActive is the default, so don't bother with them
+
+       mk_export binder_name zonked_mono_id
+         = (tyvars, 
+            attachInlinePhase inline_phases poly_id,
+            zonked_mono_id)
+         where
+           (tyvars, poly_id) = 
+               case maybeSig tc_ty_sigs binder_name of
+                 Just (TySigInfo sig_poly_id sig_tyvars _ _ _ _ _) -> 
+                       (sig_tyvars, sig_poly_id)
+                 Nothing -> (real_tyvars_to_gen, new_poly_id)
+
+           new_poly_id = mkLocalId binder_name poly_ty
+           poly_ty = mkForAllTys real_tyvars_to_gen
+                   $ mkFunTys dict_tys 
+                   $ idType zonked_mono_id
+               -- It's important to build a fully-zonked poly_ty, because
+               -- we'll slurp out its free type variables when extending the
+               -- local environment (tcExtendLocalValEnv); if it's not zonked
+               -- it appears to have free tyvars that aren't actually free 
+               -- at all.
+    in
 
 
-       -- Build bindings and IdInfos corresponding to user pragmas
-    tcPragmaSigs sigs                  `thenTc` \ (prag_info_fn, prag_binds, prag_lie) ->
+    traceTc (text "binding:" <+> ppr ((zonked_dict_ids, dict_binds),
+                                     exports, map idType poly_ids)) `thenM_`
 
 
-       -- Now do whatever happens next, in the augmented envt
-    do_next                            `thenTc` \ (thing, thing_lie, thing_ty) ->
+       -- Check for an unlifted, non-overloaded group
+       -- In that case we must make extra checks
+    if any (isUnLiftedType . idType) zonked_mono_ids && null zonked_dict_ids 
+    then       -- Some bindings are unlifted
+       checkUnliftedBinds top_lvl is_rec real_tyvars_to_gen mbind      `thenM_` 
+       
+       extendLIEs lie_req                      `thenM_`
+       returnM (
+           AbsBinds [] [] exports inlines mbind',
+               -- Do not generate even any x=y bindings
+           poly_ids
+        )
+
+    else       -- The normal case
+    extendLIEs lie_free                                `thenM_`
+    returnM (
+       AbsBinds real_tyvars_to_gen
+                zonked_dict_ids
+                exports
+                inlines
+                (dict_binds `andMonoBinds` mbind'),
+       poly_ids
+    )
 
 
-       -- Create specialisations of functions bound here
-    bindInstsOfLocalFuns (prag_lie `plusLIE` thing_lie)
-                         poly_ids      `thenTc` \ (lie2, inst_mbinds) ->
+attachInlinePhase inline_phases bndr
+  = case lookupFM inline_phases (idName bndr) of
+       Just prag -> bndr `setInlinePragma` prag
+       Nothing   -> bndr
+
+-- Check that non-overloaded unlifted bindings are
+--     a) non-recursive,
+--     b) not top level, 
+--     c) non-polymorphic
+--     d) not a multiple-binding group (more or less implied by (a))
+
+checkUnliftedBinds top_lvl is_rec real_tyvars_to_gen mbind
+  = ASSERT( not (any ((eqKind unliftedTypeKind) . tyVarKind) real_tyvars_to_gen) )
+               -- The instCantBeGeneralised stuff in tcSimplify should have
+               -- already raised an error if we're trying to generalise an 
+               -- unboxed tyvar (NB: unboxed tyvars are always introduced 
+               -- along with a class constraint) and it's better done there 
+               -- because we have more precise origin information.
+               -- That's why we just use an ASSERT here.
+
+    checkTc (isNotTopLevel top_lvl)
+           (unliftedBindErr "Top-level" mbind)         `thenM_`
+    checkTc (isNonRec is_rec)
+           (unliftedBindErr "Recursive" mbind)         `thenM_`
+    checkTc (single_bind mbind)
+           (unliftedBindErr "Multiple" mbind)          `thenM_`
+    checkTc (null real_tyvars_to_gen)
+           (unliftedBindErr "Polymorphic" mbind)
 
 
-       -- All done
-    let
-       final_lie   = lie2 `plusLIE` poly_lie
-       final_binds = poly_binds `ThenBinds`
-                     SingleBind (NonRecBind inst_mbinds) `ThenBinds`
-                     prag_binds
-    in
-    returnTc (prag_info_fn, (combiner final_binds thing, final_lie, thing_ty))
-    )                                  `thenTc` \ (_, result) ->
-    returnTc result
   where
   where
-    binder_names = map fst (bagToList (collectBinders bind))
+    single_bind (PatMonoBind _ _ _)   = True
+    single_bind (FunMonoBind _ _ _ _) = True
+    single_bind other                = False
 \end{code}
 
 
 \end{code}
 
 
-%************************************************************************
-%*                                                                     *
-\subsection{tcBindWithSigs}
-%*                                                                     *
-%************************************************************************
+Polymorphic recursion
+~~~~~~~~~~~~~~~~~~~~~
+The game plan for polymorphic recursion in the code above is 
 
 
-@tcBindWithSigs@ deals with a single binding group.  It does generalisation,
-so all the clever stuff is in here.
+       * Bind any variable for which we have a type signature
+         to an Id with a polymorphic type.  Then when type-checking 
+         the RHSs we'll make a full polymorphic call.
 
 
-\begin{code}
-tcBindWithSigs binder_names bind sigs prag_info_fn
-  =    -- Create a new identifier for each binder, with each being given
-       -- a fresh unique, and a type-variable type.
-    tcGetUniques no_of_binders                 `thenNF_Tc` \ uniqs ->
-    newTyVarTys no_of_binders kind             `thenNF_Tc` \ tys ->
-    let
-       mono_ids           = zipWith3Equal "tcBindAndSigs" mk_id binder_names uniqs tys
-       mk_id name uniq ty = mkUserLocal (getOccName name) uniq ty (getSrcLoc name)
-    in
+This fine, but if you aren't a bit careful you end up with a horrendous
+amount of partial application and (worse) a huge space leak. For example:
 
 
-       -- TYPECHECK THE SIGNATURES
-    mapTc tcTySig ty_sigs                              `thenTc` \ tc_ty_sigs ->
+       f :: Eq a => [a] -> [a]
+       f xs = ...f...
 
 
-       -- TYPECHECK THE BINDINGS
-    tcMonoBinds mbind binder_names mono_ids tc_ty_sigs `thenTc` \ (mbind', lie) ->
+If we don't take care, after typechecking we get
 
 
-       -- CHECK THAT THE SIGNATURES MATCH
-       -- (must do this before getTyVarsToGen)
-    checkSigMatch (binder_names `zip` mono_ids) tc_ty_sigs     `thenTc` \ sig_theta ->
-       
-       -- COMPUTE VARIABLES OVER WHICH TO QUANTIFY, namely tyvars_to_gen
-       -- The tyvars_not_to_gen are free in the environment, and hence
-       -- candidates for generalisation, but sometimes the monomorphism
-       -- restriction means we can't generalise them nevertheless
-    mapNF_Tc (zonkTcType . idType) mono_ids            `thenNF_Tc` \ mono_id_types ->
-    getTyVarsToGen is_unrestricted mono_id_types lie   `thenTc` \ (tyvars_not_to_gen, tyvars_to_gen) ->
-    let
-       tyvars_to_gen_list = tyVarSetToList tyvars_to_gen       -- Commit to a particular order
-    in
+       f = /\a -> \d::Eq a -> let f' = f a d
+                              in
+                              \ys:[a] -> ...f'...
 
 
-       -- SIMPLIFY THE LIE
-    tcExtendGlobalTyVars tyvars_not_to_gen (
-       if null tc_ty_sigs then
-               -- No signatures, so just simplify the lie
-           tcSimplify tyvars_to_gen lie                `thenTc` \ (lie_free, dict_binds, lie_bound) ->
-           returnTc (lie_free, dict_binds, map instToId (bagToList lie_bound))
+Notice the the stupid construction of (f a d), which is of course
+identical to the function we're executing.  In this case, the
+polymorphic recursion isn't being used (but that's a very common case).
+We'd prefer
 
 
-       else
-           newDicts SignatureOrigin sig_theta          `thenNF_Tc` \ (dicts_sig, dict_ids) ->
-               -- It's important that sig_theta is zonked, because
-               -- dict_id is later used to form the type of the polymorphic thing,
-               -- and forall-types must be zonked so far as their bound variables
-               -- are concerned
+       f = /\a -> \d::Eq a -> letrec
+                                fm = \ys:[a] -> ...fm...
+                              in
+                              fm
 
 
-               -- Check that the needed dicts can be expressed in
-               -- terms of the signature ones
-           tcAddErrCtxt (sigsCtxt tysig_names) $
-           tcSimplifyAndCheck tyvars_to_gen dicts_sig lie      `thenTc` \ (lie_free, dict_binds) ->
-           returnTc (lie_free, dict_binds, dict_ids)
+This can lead to a massive space leak, from the following top-level defn
+(post-typechecking)
 
 
-    )                                          `thenTc` \ (lie_free, dict_binds, dicts_bound) ->
+       ff :: [Int] -> [Int]
+       ff = f Int dEqInt
 
 
-       -- DEAL WITH TYPE VARIABLE KINDS
-    defaultUncommittedTyVars tyvars_to_gen_list        `thenTc_`
+Now (f dEqInt) evaluates to a lambda that has f' as a free variable; but
+f' is another thunk which evaluates to the same thing... and you end
+up with a chain of identical values all hung onto by the CAF ff.
 
 
-        -- BUILD THE POLYMORPHIC RESULT IDs
-    let
-       dict_tys    = map tcIdType dicts_bound
-       poly_tys    = map (mkForAllTys tyvars_to_gen_list . mkFunTys dict_tys) mono_id_types
-       poly_ids    = zipWithEqual "genspecetc" mk_poly binder_names poly_tys
-       mk_poly name ty = mkUserId name ty (prag_info_fn name)
-    in
+       ff = f Int dEqInt
 
 
-       -- MAKE EXTRA BINDS FOR THE TYPE-SIG POLYMORPHIC VARIABLES
-       -- These are only needed to scope over the right-hand sides of the group,
-       -- and hence aren't needed at all for non-recursive definitions.
-       --
-       -- Alas, the polymorphic variables from the type signature can't coincide
-       -- with the poly_ids because the order of their type variables may not be
-       -- the same.  These bindings just swizzle the type variables.
-    let
-       poly_binds | is_rec_bind = map mk_poly_bind tc_ty_sigs
-                  | otherwise   = []
+          = let f' = f Int dEqInt in \ys. ...f'...
 
 
-       mk_poly_bind (TySigInfo name rhs_poly_id rhs_tyvars _ _ _)
-         = (TcId rhs_poly_id, TyLam rhs_tyvars $
-                              TyApp (HsVar (TcId main_poly_id)) $
-                              mkTyVarTys tyvars_to_gen_list)
-         where
-           main_poly_id = head (filter ((== name) . getName) poly_ids)
-    in
-        -- BUILD RESULTS
-    returnTc (
-        AbsBinds tyvars_to_gen_list
-                 dicts_bound
-                 (zipEqual "genBinds" (map TcId mono_ids) (map TcId poly_ids))
-                 (poly_binds ++ dict_binds)
-                 (wrap_it mbind'),
-        lie_free,
-        poly_ids
-    )
-  where
-    no_of_binders = length binder_names
+          = let f' = let f' = f Int dEqInt in \ys. ...f'...
+                     in \ys. ...f'...
 
 
-    is_rec_bind = case bind of
-                       NonRecBind _ -> False
-                       RecBind _    -> True
+Etc.
+Solution: when typechecking the RHSs we always have in hand the
+*monomorphic* Ids for each binding.  So we just need to make sure that
+if (Method f a d) shows up in the constraints emerging from (...f...)
+we just use the monomorphic Id.  We achieve this by adding monomorphic Ids
+to the "givens" when simplifying constraints.  That's what the "lies_avail"
+is doing.
 
 
-    mbind = case bind of
-               NonRecBind mb -> mb
-               RecBind mb    -> mb
 
 
-    ty_sigs         = [sig  | sig@(Sig name _ _) <- sigs]
-    tysig_names     = [name | (Sig name _ _) <- ty_sigs]
-    is_unrestricted = isUnRestrictedGroup tysig_names mbind
+%************************************************************************
+%*                                                                     *
+\subsection{getTyVarsToGen}
+%*                                                                     *
+%************************************************************************
+
+\begin{code}
+generalise binder_names mbind tau_tvs lie_req sigs =
+
+  -- check for -fno-monomorphism-restriction
+  doptM Opt_NoMonomorphismRestriction          `thenM` \ no_MR ->
+  let is_unrestricted | no_MR    = True
+                     | otherwise = isUnRestrictedGroup tysig_names mbind
+  in
+
+  if not is_unrestricted then  -- RESTRICTED CASE
+       -- Check signature contexts are empty 
+    checkTc (all is_mono_sig sigs)
+           (restrictedBindCtxtErr binder_names)        `thenM_`
+
+       -- Now simplify with exactly that set of tyvars
+       -- We have to squash those Methods
+    tcSimplifyRestricted doc tau_tvs lie_req           `thenM` \ (qtvs, binds) ->
+
+       -- Check that signature type variables are OK
+    checkSigsTyVars qtvs sigs                          `thenM` \ final_qtvs ->
+
+    returnM (final_qtvs, binds, [])
+
+  else if null sigs then       -- UNRESTRICTED CASE, NO TYPE SIGS
+    tcSimplifyInfer doc tau_tvs lie_req
+
+  else                                 -- UNRESTRICTED CASE, WITH TYPE SIGS
+       -- CHECKING CASE: Unrestricted group, there are type signatures
+       -- Check signature contexts are identical
+    checkSigsCtxts sigs                        `thenM` \ (sig_avails, sig_dicts) ->
+    
+       -- Check that the needed dicts can be
+       -- expressed in terms of the signature ones
+    tcSimplifyInferCheck doc tau_tvs sig_avails lie_req        `thenM` \ (forall_tvs, dict_binds) ->
+       
+       -- Check that signature type variables are OK
+    checkSigsTyVars forall_tvs sigs                    `thenM` \ final_qtvs ->
+
+    returnM (final_qtvs, dict_binds, sig_dicts)
+
+  where
+    tysig_names = map (idName . tcSigPolyId) sigs
+    is_mono_sig (TySigInfo _ _ theta _ _ _ _) = null theta
+
+    doc = ptext SLIT("type signature(s) for") <+> pprBinders binder_names
 
 
-    kind | is_rec_bind = mkBoxedTypeKind       -- Recursive, so no unboxed types
-        | otherwise   = mkTypeKind             -- Non-recursive, so we permit unboxed types
+-----------------------
+       -- CHECK THAT ALL THE SIGNATURE CONTEXTS ARE UNIFIABLE
+       -- The type signatures on a mutually-recursive group of definitions
+       -- must all have the same context (or none).
+       --
+       -- We unify them because, with polymorphic recursion, their types
+       -- might not otherwise be related.  This is a rather subtle issue.
+       -- ToDo: amplify
+checkSigsCtxts sigs@(TySigInfo id1 sig_tvs theta1 _ _ _ src_loc : other_sigs)
+  = addSrcLoc src_loc                  $
+    mappM_ check_one other_sigs                `thenM_` 
+    if null theta1 then
+       returnM ([], [])                -- Non-overloaded type signatures
+    else
+    newDicts SignatureOrigin theta1    `thenM` \ sig_dicts ->
+    let
+       -- The "sig_avails" is the stuff available.  We get that from
+       -- the context of the type signature, BUT ALSO the lie_avail
+       -- so that polymorphic recursion works right (see comments at end of fn)
+       sig_avails = sig_dicts ++ sig_meths
+    in
+    returnM (sig_avails, map instToId sig_dicts)
+  where
+    sig1_dict_tys = map mkPredTy theta1
+    sig_meths    = concat [insts | TySigInfo _ _ _ _ _ insts _ <- sigs]
 
 
-    wrap_it mbind | is_rec_bind = RecBind mbind
-                 | otherwise   = NonRecBind mbind
+    check_one sig@(TySigInfo id _ theta _ _ _ _)
+       = addErrCtxt (sigContextsCtxt id1 id)                   $
+        checkTc (equalLength theta theta1) sigContextsErr      `thenM_`
+        unifyTauTyLists sig1_dict_tys (map mkPredTy theta)
 
 
+checkSigsTyVars :: [TcTyVar] -> [TcSigInfo] -> TcM [TcTyVar]
+checkSigsTyVars qtvs sigs 
+  = mappM check_one sigs       `thenM` \ sig_tvs_s ->
+    let
+       -- Sigh.  Make sure that all the tyvars in the type sigs
+       -- appear in the returned ty var list, which is what we are
+       -- going to generalise over.  Reason: we occasionally get
+       -- silly types like
+       --      type T a = () -> ()
+       --      f :: T a
+       --      f () = ()
+       -- Here, 'a' won't appear in qtvs, so we have to add it
+
+       sig_tvs = foldr (unionVarSet . mkVarSet) emptyVarSet sig_tvs_s
+       all_tvs = mkVarSet qtvs `unionVarSet` sig_tvs
+    in
+    returnM (varSetElems all_tvs)
+  where
+    check_one (TySigInfo id sig_tyvars sig_theta sig_tau _ _ src_loc)
+      = addSrcLoc src_loc                                              $
+       addErrCtxt (ptext SLIT("When checking the type signature for") 
+                     <+> quotes (ppr id))                              $
+       addErrCtxtM (sigCtxt id sig_tyvars sig_theta sig_tau)           $
+       checkSigTyVarsWrt (idFreeTyVars id) sig_tyvars
 \end{code}
 
 \end{code}
 
-@getImplicitStuffToGen@ decides what type variables generalise over.
+@getTyVarsToGen@ decides what type variables to generalise over.
 
 For a "restricted group" -- see the monomorphism restriction
 for a definition -- we bind no dictionaries, and
 
 For a "restricted group" -- see the monomorphism restriction
 for a definition -- we bind no dictionaries, and
@@ -368,6 +577,8 @@ generalise.  We must be careful about doing this:
        Another, more common, example is when there's a Method inst in
        the LIE, whose type might very well involve non-overloaded
        type variables.
        Another, more common, example is when there's a Method inst in
        the LIE, whose type might very well involve non-overloaded
        type variables.
+  [NOTE: Jan 2001: I don't understand the problem here so I'm doing 
+       the simple thing instead]
 
  (b) On the other hand, we mustn't generalise tyvars which are constrained,
        because we are going to pass on out the unmodified LIE, with those
 
  (b) On the other hand, we mustn't generalise tyvars which are constrained,
        because we are going to pass on out the unmodified LIE, with those
@@ -378,62 +589,22 @@ constrained tyvars. We don't use any of the results, except to
 find which tyvars are constrained.
 
 \begin{code}
 find which tyvars are constrained.
 
 \begin{code}
-getTyVarsToGen is_unrestricted mono_id_types lie
-  = tcGetGlobalTyVars                          `thenNF_Tc` \ free_tyvars ->
-    let
-       mentioned_tyvars = tyVarsOfTypes mono_id_types
-       tyvars_to_gen    = mentioned_tyvars `minusTyVarSet` free_tyvars
-    in
-    if is_unrestricted
-    then
-       returnTc (emptyTyVarSet, tyvars_to_gen)
-    else
-       tcSimplify tyvars_to_gen lie        `thenTc` \ (_, _, constrained_dicts) ->
-       let
-         -- ASSERT: dicts_sig is already zonked!
-           constrained_tyvars    = foldrBag (unionTyVarSets . tyVarsOfInst) emptyTyVarSet constrained_dicts
-           reduced_tyvars_to_gen = tyvars_to_gen `minusTyVarSet` constrained_tyvars
-        in
-        returnTc (constrained_tyvars, reduced_tyvars_to_gen)
-\end{code}
-
-
-\begin{code}
 isUnRestrictedGroup :: [Name]          -- Signatures given for these
                    -> RenamedMonoBinds
                    -> Bool
 
 is_elem v vs = isIn "isUnResMono" v vs
 
 isUnRestrictedGroup :: [Name]          -- Signatures given for these
                    -> RenamedMonoBinds
                    -> Bool
 
 is_elem v vs = isIn "isUnResMono" v vs
 
-isUnRestrictedGroup sigs (PatMonoBind (VarPatIn v) _ _) = v `is_elem` sigs
-isUnRestrictedGroup sigs (PatMonoBind other      _ _)  = False
+isUnRestrictedGroup sigs (PatMonoBind other        _ _) = False
 isUnRestrictedGroup sigs (VarMonoBind v _)             = v `is_elem` sigs
 isUnRestrictedGroup sigs (VarMonoBind v _)             = v `is_elem` sigs
-isUnRestrictedGroup sigs (FunMonoBind _ _ _ _)         = True
+isUnRestrictedGroup sigs (FunMonoBind v _ matches _)   = isUnRestrictedMatch matches || 
+                                                         v `is_elem` sigs
 isUnRestrictedGroup sigs (AndMonoBinds mb1 mb2)                = isUnRestrictedGroup sigs mb1 &&
                                                          isUnRestrictedGroup sigs mb2
 isUnRestrictedGroup sigs EmptyMonoBinds                        = True
 isUnRestrictedGroup sigs (AndMonoBinds mb1 mb2)                = isUnRestrictedGroup sigs mb1 &&
                                                          isUnRestrictedGroup sigs mb2
 isUnRestrictedGroup sigs EmptyMonoBinds                        = True
-\end{code}
-
-@defaultUncommittedTyVars@ checks for generalisation over unboxed
-types, and defaults any TypeKind TyVars to BoxedTypeKind.
-
-\begin{code}
-defaultUncommittedTyVars tyvars
-  = ASSERT( null unboxed_kind_tyvars ) -- The instCantBeGeneralised stuff in tcSimplify
-                                       -- should have dealt with unboxed type variables;
-                                       -- and it's better done there because we have more
-                                       -- precise origin information.
-                                       -- That's why we call this *after* simplifying.
-                                       -- (NB: unboxed tyvars are always introduced along
-                                       --  with a class constraint.)
-
-    mapTc box_it unresolved_kind_tyvars
-  where
-    unboxed_kind_tyvars    = filter (isUnboxedTypeKind . tyVarKind) tyvars
-    unresolved_kind_tyvars = filter (isTypeKind        . tyVarKind) tyvars
 
 
-    box_it tyvar = newTyVarTy mkBoxedTypeKind  `thenNF_Tc` \ boxed_ty ->
-                  unifyTauTy boxed_ty (mkTyVarTy tyvar) 
+isUnRestrictedMatch (Match [] _ _ : _) = False -- No args => like a pattern binding
+isUnRestrictedMatch other             = True   -- Some args => a function binding
 \end{code}
 
 
 \end{code}
 
 
@@ -448,180 +619,129 @@ The signatures have been dealt with already.
 
 \begin{code}
 tcMonoBinds :: RenamedMonoBinds 
 
 \begin{code}
 tcMonoBinds :: RenamedMonoBinds 
-           -> [Name] -> [TcIdBndr s]
-           -> [TcSigInfo s]
-           -> TcM s (TcMonoBinds s, LIE s)
-
-tcMonoBinds mbind binder_names mono_ids tc_ty_sigs
-  = tcExtendLocalValEnv binder_names mono_ids (
-       tc_mono_binds mbind
-    )
-  where
-    sig_names = [name | (TySigInfo name _ _ _ _ _) <- tc_ty_sigs]
-    sig_ids   = [id   | (TySigInfo _   id _ _ _ _) <- tc_ty_sigs]
-
-    tc_mono_binds EmptyMonoBinds = returnTc (EmptyMonoBinds, emptyLIE)
-
-    tc_mono_binds (AndMonoBinds mb1 mb2)
-      = tc_mono_binds mb1              `thenTc` \ (mb1a, lie1) ->
-        tc_mono_binds mb2              `thenTc` \ (mb2a, lie2) ->
-        returnTc (AndMonoBinds mb1a mb2a, lie1 `plusLIE` lie2)
-
-    tc_mono_binds (FunMonoBind name inf matches locn)
-      = tcAddSrcLoc locn                               $
-       tcLookupLocalValueOK "tc_mono_binds" name       `thenNF_Tc` \ id ->
-
-               -- Before checking the RHS, extend the envt with
-               -- bindings for the *polymorphic* Ids from any type signatures
-       tcExtendLocalValEnv sig_names sig_ids           $
-       tcMatchesFun name (idType id) matches           `thenTc` \ (matches', lie) ->
-
-       returnTc (FunMonoBind (TcId id) inf matches' locn, lie)
-
-    tc_mono_binds bind@(PatMonoBind pat grhss_and_binds locn)
-      = tcAddSrcLoc locn                       $
-       tcPat pat                               `thenTc` \ (pat2, lie_pat, pat_ty) ->
-       tcExtendLocalValEnv sig_names sig_ids   $
-       tcGRHSsAndBinds grhss_and_binds         `thenTc` \ (grhss_and_binds2, lie, grhss_ty) ->
-       tcAddErrCtxt (patMonoBindsCtxt bind)    $
-       unifyTauTy pat_ty grhss_ty              `thenTc_`
-       returnTc (PatMonoBind pat2 grhss_and_binds2 locn,
-                 plusLIE lie_pat lie)
-\end{code}
-
-%************************************************************************
-%*                                                                     *
-\subsection{Signatures}
-%*                                                                     *
-%************************************************************************
-
-@tcSigs@ checks the signatures for validity, and returns a list of
-{\em freshly-instantiated} signatures.  That is, the types are already
-split up, and have fresh type variables installed.  All non-type-signature
-"RenamedSigs" are ignored.
-
-The @TcSigInfo@ contains @TcTypes@ because they are unified with
-the variable's type, and after that checked to see whether they've
-been instantiated.
-
-\begin{code}
-data TcSigInfo s
-  = TySigInfo      Name
-                   (TcIdBndr s)        -- *Polymorphic* binder for this value...
-                   [TcTyVar s] (TcThetaType s) (TcTauType s)
-                   SrcLoc
-\end{code}
-
-
-\begin{code}
-tcTySig :: RenamedSig -> TcM s (TcSigInfo s)
-
-tcTySig (Sig v ty src_loc)
- = tcAddSrcLoc src_loc $
-   tcHsType ty                 `thenTc` \ sigma_ty ->
-   tcGetUnique                         `thenNF_Tc` \ uniq ->
-   tcInstSigType sigma_ty      `thenNF_Tc` \ sigma_ty' ->
-   let
-     poly_id = mkUserLocal (getOccName v) uniq sigma_ty' src_loc
-     (tyvars', theta', tau') = splitSigmaTy sigma_ty'
-   in
-   returnTc (TySigInfo v poly_id tyvars' theta' tau' src_loc)
-\end{code}
-
-@checkSigMatch@ does the next step in checking signature matching.
-The tau-type part has already been unified.  What we do here is to
-check that this unification has not over-constrained the (polymorphic)
-type variables of the original signature type.
-
-The error message here is somewhat unsatisfactory, but it'll do for
-now (ToDo).
-
-\begin{code}
-checkSigMatch binder_names_w_mono_isd []
-  = returnTc (error "checkSigMatch")
-
-checkSigMatch binder_names_w_mono_ids tc_ty_sigs 
-  = 
-
-       -- CHECK THAT THE SIGNATURE TYVARS AND TAU_TYPES ARE OK
-       -- Doesn't affect substitution
-    mapTc check_one_sig tc_ty_sigs     `thenTc_`
-
-       -- CHECK THAT ALL THE SIGNATURE CONTEXTS ARE IDENTICAL
-       -- The type signatures on a mutually-recursive group of definitions
-       -- must all have the same context (or none).
-       -- We have to zonk them first to make their type variables line up
-    mapNF_Tc get_zonked_theta tc_ty_sigs               `thenNF_Tc` \ (theta:thetas) ->
-    checkTc (all (eqSimpleTheta theta) thetas) 
-           (sigContextsErr tc_ty_sigs)         `thenTc_`
-
-    returnTc theta
+           -> [TcSigInfo] -> RecFlag
+           -> TcM (TcMonoBinds, 
+                   Bag (Name,          -- Bound names
+                        TcId))         -- Corresponding monomorphic bound things
+
+tcMonoBinds mbinds tc_ty_sigs is_rec
+       -- Three stages: 
+       -- 1. Check the patterns, building up an environment binding
+       --    the variables in this group (in the recursive case)
+       -- 2. Extend the environment
+       -- 3. Check the RHSs
+  = tc_mb_pats mbinds          `thenM` \ (complete_it, xve) ->
+    tcExtendLocalValEnv2 (bagToList xve) complete_it
   where
   where
-    check_one_sig (TySigInfo name id sig_tyvars _ sig_tau src_loc)
-      = tcAddSrcLoc src_loc    $
-       tcAddErrCtxt (sigCtxt id) $
-       unifyTauTy sig_tau mono_id_ty           `thenTc_`
-       checkSigTyVars sig_tyvars sig_tau
-      where
-       mono_id_ty = idType (assoc "checkSigMatch" binder_names_w_mono_ids name)
-
-    get_zonked_theta (TySigInfo _ _ _ theta _ _)
-      = mapNF_Tc (\ (c,t) -> zonkTcType t `thenNF_Tc` \ t' -> returnNF_Tc (c,t')) theta
-\end{code}
-
-
-@checkSigTyVars@ is used after the type in a type signature has been unified with
-the actual type found.  It then checks that the type variables of the type signature
-are
-       (a) still all type variables
-               eg matching signature [a] against inferred type [(p,q)]
-               [then a will be unified to a non-type variable]
-
-       (b) still all distinct
-               eg matching signature [(a,b)] against inferred type [(p,p)]
-               [then a and b will be unified together]
+    tc_mb_pats EmptyMonoBinds 
+      = returnM (returnM (EmptyMonoBinds, emptyBag), emptyBag)
 
 
-BUT ACTUALLY THESE FIRST TWO ARE FORCED BY USING DontBind TYVARS
-
-       (c) not mentioned in the environment
-               eg the signature for f in this:
-
-                       g x = ... where
-                                       f :: a->[a]
-                                       f y = [x,y]
+    tc_mb_pats (AndMonoBinds mb1 mb2)
+      = tc_mb_pats mb1         `thenM` \ (complete_it1, xve1) ->
+        tc_mb_pats mb2         `thenM` \ (complete_it2, xve2) ->
+       let
+          complete_it = complete_it1   `thenM` \ (mb1', bs1) ->
+                        complete_it2   `thenM` \ (mb2', bs2) ->
+                        returnM (AndMonoBinds mb1' mb2', bs1 `unionBags` bs2)
+       in
+       returnM (complete_it, xve1 `unionBags` xve2)
+
+    tc_mb_pats (FunMonoBind name inf matches locn)
+               -- Three cases:
+               --      a) Type sig supplied
+               --      b) No type sig and recursive
+               --      c) No type sig and non-recursive
+
+      | Just sig <- maybeSig tc_ty_sigs name 
+      = let    -- (a) There is a type signature
+               -- Use it for the environment extension, and check
+               -- the RHS has the appropriate type (with outer for-alls stripped off)
+          mono_id = tcSigMonoId sig
+          mono_ty = idType mono_id
+          complete_it = addSrcLoc locn                                 $
+                        tcMatchesFun name matches (Check mono_ty)      `thenM` \ matches' ->
+                        returnM (FunMonoBind mono_id inf matches' locn, 
+                                 unitBag (name, mono_id))
+       in
+       returnM (complete_it, if isRec is_rec then unitBag (name,tcSigPolyId sig) 
+                                             else emptyBag)
+
+      | isRec is_rec
+      =                -- (b) No type signature, and recursive
+               -- So we must use an ordinary H-M type variable
+               -- which means the variable gets an inferred tau-type
+       newLocalName name               `thenM` \ mono_name ->
+       newTyVarTy openTypeKind         `thenM` \ mono_ty ->
+       let
+          mono_id     = mkLocalId mono_name mono_ty
+          complete_it = addSrcLoc locn                                 $
+                        tcMatchesFun name matches (Check mono_ty)      `thenM` \ matches' ->
+                        returnM (FunMonoBind mono_id inf matches' locn, 
+                                 unitBag (name, mono_id))
+       in
+       returnM (complete_it, unitBag (name, mono_id))
+
+      | otherwise      -- (c) No type signature, and non-recursive
+      =        let             -- So we can use a 'hole' type to infer a higher-rank type
+          complete_it 
+               = addSrcLoc locn                                $
+                 newHole                                       `thenM` \ hole -> 
+                 tcMatchesFun name matches (Infer hole)        `thenM` \ matches' ->
+                 readMutVar hole                               `thenM` \ fun_ty ->
+                 newLocalName name                             `thenM` \ mono_name ->
+                 let
+                    mono_id = mkLocalId mono_name fun_ty
+                 in
+                 returnM (FunMonoBind mono_id inf matches' locn, 
+                          unitBag (name, mono_id))
+       in
+       returnM (complete_it, emptyBag)
+       
+    tc_mb_pats bind@(PatMonoBind pat grhss locn)
+      = addSrcLoc locn         $
 
 
-               Here, f is forced to be monorphic by the free occurence of x.
+               --      Now typecheck the pattern
+               -- We do now support binding fresh (not-already-in-scope) scoped 
+               -- type variables in the pattern of a pattern binding.  
+               -- For example, this is now legal:
+               --      (x::a, y::b) = e
+               -- The type variables are brought into scope in tc_binds_and_then,
+               -- so we don't have to do anything here.
 
 
-Before doing this, the substitution is applied to the signature type variable.
+       newHole                                 `thenM` \ hole -> 
+       tcPat tc_pat_bndr pat (Infer hole)      `thenM` \ (pat', tvs, ids, lie_avail) ->
+       readMutVar hole                         `thenM` \ pat_ty ->
 
 
-\begin{code}
-checkSigTyVars :: [TcTyVar s]          -- The original signature type variables
-              -> TcType s              -- signature type (for err msg)
-              -> TcM s ()
+       -- Don't know how to deal with pattern-bound existentials yet
+        checkTc (isEmptyBag tvs && null lie_avail) 
+               (existentialExplode bind)       `thenM_` 
 
 
-checkSigTyVars sig_tyvars sig_tau
-  = tcGetGlobalTyVars                  `thenNF_Tc` \ globals ->
-    let
-       mono_tyvars = filter (`elementOfTyVarSet` globals) sig_tyvars
-    in
-       -- TEMPORARY FIX
-       -- Until the final Bind-handling stuff is in, several type signatures in the same
-       -- bindings group can cause the signature type variable from the different
-       -- signatures to be unified.  So we still need to zonk and check point (b).
-       -- Remove when activating the new binding code
-    mapNF_Tc zonkTcTyVar sig_tyvars    `thenNF_Tc` \ sig_tys ->
-    checkTcM (hasNoDups (map (getTyVar "checkSigTyVars") sig_tys))
-            (zonkTcType sig_tau        `thenNF_Tc` \ sig_tau' ->
-             failTc (badMatchErr sig_tau sig_tau')
-            )                          `thenTc_`
-
-
-       -- Check point (c)
-       -- We want to report errors in terms of the original signature tyvars,
-       -- ie sig_tyvars, NOT sig_tyvars'.  sig_tys and sig_tyvars' correspond
-       -- 1-1 with sig_tyvars, so we can just map back.
-    checkTc (null mono_tyvars)
-           (notAsPolyAsSigErr sig_tau mono_tyvars)
+       let
+          complete_it = addSrcLoc locn                                 $
+                        addErrCtxt (patMonoBindsCtxt bind)             $
+                        tcGRHSsPat grhss (Check pat_ty)        `thenM` \ grhss' ->
+                        returnM (PatMonoBind pat' grhss' locn, ids)
+       in
+       returnM (complete_it, if isRec is_rec then ids else emptyBag)
+
+       -- tc_pat_bndr is used when dealing with a LHS binder in a pattern.
+       -- If there was a type sig for that Id, we want to make it much
+       -- as if that type signature had been on the binder as a SigPatIn.
+       -- We check for a type signature; if there is one, we use the mono_id
+       -- from the signature.  This is how we make sure the tau part of the
+       -- signature actually matches the type of the LHS; then tc_mb_pats
+       -- ensures the LHS and RHS have the same type
+       
+    tc_pat_bndr name pat_ty
+       = case maybeSig tc_ty_sigs name of
+           Nothing  -> newLocalName name                       `thenM` \ bndr_name ->
+                       tcMonoPatBndr bndr_name pat_ty
+
+           Just sig -> addSrcLoc (getSrcLoc name)              $
+                       tcSubPat (idType mono_id) pat_ty        `thenM` \ co_fn ->
+                       returnM (co_fn, mono_id)
+                    where
+                       mono_id = tcSigMonoId sig
 \end{code}
 
 
 \end{code}
 
 
@@ -631,45 +751,13 @@ checkSigTyVars sig_tyvars sig_tau
 %*                                                                     *
 %************************************************************************
 
 %*                                                                     *
 %************************************************************************
 
-
-@tcPragmaSigs@ munches up the "signatures" that arise through *user*
+@tcSpecSigs@ munches up the specialisation "signatures" that arise through *user*
 pragmas.  It is convenient for them to appear in the @[RenamedSig]@
 part of a binding because then the same machinery can be used for
 moving them into place as is done for type signatures.
 
 pragmas.  It is convenient for them to appear in the @[RenamedSig]@
 part of a binding because then the same machinery can be used for
 moving them into place as is done for type signatures.
 
-\begin{code}
-tcPragmaSigs :: [RenamedSig]                   -- The pragma signatures
-            -> TcM s (Name -> PragmaInfo,      -- Maps name to the appropriate PragmaInfo
-                      TcHsBinds s,
-                      LIE s)
-
-tcPragmaSigs sigs = returnTc ( \name -> NoPragmaInfo, EmptyBinds, emptyLIE )
-
-{- 
-tcPragmaSigs sigs
-  = mapAndUnzip3Tc tcPragmaSig sigs    `thenTc` \ (names_w_id_infos, binds, lies) ->
-    let
-       name_to_info name = foldr ($) noIdInfo
-                                 [info_fn | (n,info_fn) <- names_w_id_infos, n==name]
-    in
-    returnTc (name_to_info,
-             foldr ThenBinds EmptyBinds binds,
-             foldr plusLIE emptyLIE lies)
-\end{code}
-
-Here are the easy cases for tcPragmaSigs
-
-\begin{code}
-tcPragmaSig (DeforestSig name loc)
-  = returnTc ((name, addDeforestInfo DoDeforest),EmptyBinds,emptyLIE)
-tcPragmaSig (InlineSig name loc)
-  = returnTc ((name, addUnfoldInfo (iWantToBeINLINEd UnfoldAlways)), EmptyBinds, emptyLIE)
-tcPragmaSig (MagicUnfoldingSig name string loc)
-  = returnTc ((name, addUnfoldInfo (mkMagicUnfolding string)), EmptyBinds, emptyLIE)
-\end{code}
+They look like this:
 
 
-The interesting case is for SPECIALISE pragmas.  There are two forms.
-Here's the first form:
 \begin{verbatim}
        f :: Ord a => [a] -> b -> b
        {-# SPECIALIZE f :: [Int] -> b -> b #-}
 \begin{verbatim}
        f :: Ord a => [a] -> b -> b
        {-# SPECIALIZE f :: [Int] -> b -> b #-}
@@ -692,113 +780,44 @@ specialiser will subsequently discover that there's a call of @f@ at
 Int, and will create a specialisation for @f@.  After that, the
 binding for @f*@ can be discarded.
 
 Int, and will create a specialisation for @f@.  After that, the
 binding for @f*@ can be discarded.
 
-The second form is this:
-\begin{verbatim}
-       f :: Ord a => [a] -> b -> b
-       {-# SPECIALIZE f :: [Int] -> b -> b = g #-}
-\end{verbatim}
-
-Here @g@ is specified as a function that implements the specialised
-version of @f@.  Suppose that g has type (a->b->b); that is, g's type
-is more general than that required.  For this we generate
-\begin{verbatim}
-       f@Int = /\b -> g Int b
-       f* = f@Int
-\end{verbatim}
-
-Here @f@@Int@ is a SpecId, the specialised version of @f@.  It inherits
-f's export status etc.  @f*@ is a SpecPragmaId, as before, which just serves
-to prevent @f@@Int@ from being discarded prematurely.  After specialisation,
-if @f@@Int@ is going to be used at all it will be used explicitly, so the simplifier can
-discard the f* binding.
-
-Actually, there is really only point in giving a SPECIALISE pragma on exported things,
-and the simplifer won't discard SpecIds for exporte things anyway, so maybe this is
-a bit of overkill.
+We used to have a form
+       {-# SPECIALISE f :: <type> = g #-}
+which promised that g implemented f at <type>, but we do that with 
+a RULE now:
+       {-# SPECIALISE (f::<type) = g #-}
 
 \begin{code}
 
 \begin{code}
-tcPragmaSig (SpecSig name poly_ty maybe_spec_name src_loc)
-  = tcAddSrcLoc src_loc                                $
-    tcAddErrCtxt (valSpecSigCtxt name spec_ty) $
+tcSpecSigs :: [RenamedSig] -> TcM TcMonoBinds
+tcSpecSigs (SpecSig name poly_ty src_loc : sigs)
+  =    -- SPECIALISE f :: forall b. theta => tau  =  g
+    addSrcLoc src_loc                          $
+    addErrCtxt (valSpecSigCtxt name poly_ty)   $
 
        -- Get and instantiate its alleged specialised type
 
        -- Get and instantiate its alleged specialised type
-    tcHsType poly_ty                           `thenTc` \ sig_sigma ->
-    tcInstSigType  sig_sigma                   `thenNF_Tc` \ sig_ty ->
-    let
-       (sig_tyvars, sig_theta, sig_tau) = splitSigmaTy sig_ty
-       origin = ValSpecOrigin name
-    in
+    tcHsSigType (FunSigCtxt name) poly_ty      `thenM` \ sig_ty ->
 
 
-       -- Check that the SPECIALIZE pragma had an empty context
-    checkTc (null sig_theta)
-           (panic "SPECIALIZE non-empty context (ToDo: msg)") `thenTc_`
+       -- Check that f has a more general type, and build a RHS for
+       -- the spec-pragma-id at the same time
+    getLIE (tcCheckSigma (HsVar name) sig_ty)  `thenM` \ (spec_expr, spec_lie) ->
 
 
-       -- Get and instantiate the type of the id mentioned
-    tcLookupLocalValueOK "tcPragmaSig" name    `thenNF_Tc` \ main_id ->
-    tcInstSigType [] (idType main_id)          `thenNF_Tc` \ main_ty ->
+       -- Squeeze out any Methods (see comments with tcSimplifyToDicts)
+    tcSimplifyToDicts spec_lie                 `thenM` \ spec_binds ->
+
+       -- Just specialise "f" by building a SpecPragmaId binding
+       -- It is the thing that makes sure we don't prematurely 
+       -- dead-code-eliminate the binding we are really interested in.
+    newLocalName name                  `thenM` \ spec_name ->
     let
     let
-       (main_tyvars, main_rho) = splitForAllTy main_ty
-       (main_theta,main_tau)   = splitRhoTy main_rho
-       main_arg_tys            = mkTyVarTys main_tyvars
+       spec_bind = VarMonoBind (mkSpecPragmaId spec_name sig_ty)
+                               (mkHsLet spec_binds spec_expr)
     in
 
     in
 
-       -- Check that the specialised type is indeed an instance of
-       -- the type of the main function.
-    unifyTauTy sig_tau main_tau                `thenTc_`
-    checkSigTyVars sig_tyvars sig_tau  `thenTc_`
-
-       -- Check that the type variables of the polymorphic function are
-       -- either left polymorphic, or instantiate to ground type.
-       -- Also check that the overloaded type variables are instantiated to
-       -- ground type; or equivalently that all dictionaries have ground type
-    mapTc zonkTcType main_arg_tys      `thenNF_Tc` \ main_arg_tys' ->
-    zonkTcThetaType main_theta         `thenNF_Tc` \ main_theta' ->
-    tcAddErrCtxt (specGroundnessCtxt main_arg_tys')
-             (checkTc (all isGroundOrTyVarTy main_arg_tys'))           `thenTc_`
-    tcAddErrCtxt (specContextGroundnessCtxt main_theta')
-             (checkTc (and [isGroundTy ty | (_,ty) <- theta']))        `thenTc_`
-
-       -- Build the SpecPragmaId; it is the thing that makes sure we
-       -- don't prematurely dead-code-eliminate the binding we are really interested in.
-    newSpecPragmaId name sig_ty                `thenNF_Tc` \ spec_pragma_id ->
-
-       -- Build a suitable binding; depending on whether we were given
-       -- a value (Maybe Name) to be used as the specialisation.
-    case using of
-      Nothing ->               -- No implementation function specified
-
-               -- Make a Method inst for the occurrence of the overloaded function
-       newMethodWithGivenTy (OccurrenceOf name)
-                 (TcId main_id) main_arg_tys main_rho  `thenNF_Tc` \ (lie, meth_id) ->
-
-       let
-           pseudo_bind = VarMonoBind spec_pragma_id pseudo_rhs
-           pseudo_rhs  = mkHsTyLam sig_tyvars (HsVar (TcId meth_id))
-       in
-       returnTc (pseudo_bind, lie, \ info -> info)
-
-      Just spec_name ->                -- Use spec_name as the specialisation value ...
-
-               -- Type check a simple occurrence of the specialised Id
-       tcId spec_name          `thenTc` \ (spec_body, spec_lie, spec_tau) ->
-
-               -- Check that it has the correct type, and doesn't constrain the
-               -- signature variables at all
-       unifyTauTy sig_tau spec_tau             `thenTc_`
-       checkSigTyVars sig_tyvars sig_tau       `thenTc_`
-
-           -- Make a local SpecId to bind to applied spec_id
-       newSpecId main_id main_arg_tys sig_ty   `thenNF_Tc` \ local_spec_id ->
+       -- Do the rest and combine
+    tcSpecSigs sigs                    `thenM` \ binds_rest ->
+    returnM (binds_rest `andMonoBinds` spec_bind)
 
 
-       let
-           spec_rhs   = mkHsTyLam sig_tyvars spec_body
-           spec_binds = VarMonoBind local_spec_id spec_rhs
-                          `AndMonoBinds`
-                        VarMonoBind spec_pragma_id (HsVar (TcId local_spec_id))
-           spec_info  = SpecInfo spec_tys (length main_theta) local_spec_id
-       in
-       returnTc ((name, addSpecInfo spec_info), spec_binds, spec_lie)
--}
+tcSpecSigs (other_sig : sigs) = tcSpecSigs sigs
+tcSpecSigs []                = returnM EmptyMonoBinds
 \end{code}
 
 
 \end{code}
 
 
@@ -810,78 +829,46 @@ tcPragmaSig (SpecSig name poly_ty maybe_spec_name src_loc)
 
 
 \begin{code}
 
 
 \begin{code}
-patMonoBindsCtxt bind sty
-  = ppHang (ppPStr SLIT("In a pattern binding:")) 4 (ppr sty bind)
+patMonoBindsCtxt bind
+  = hang (ptext SLIT("In a pattern binding:")) 4 (ppr bind)
 
 -----------------------------------------------
 
 -----------------------------------------------
-valSpecSigCtxt v ty sty
-  = ppHang (ppPStr SLIT("In a SPECIALIZE pragma for a value:"))
-        4 (ppSep [ppBeside (pprNonSym sty v) (ppPStr SLIT(" ::")),
-                 ppr sty ty])
-
-
+valSpecSigCtxt v ty
+  = sep [ptext SLIT("In a SPECIALIZE pragma for a value:"),
+        nest 4 (ppr v <+> dcolon <+> ppr ty)]
 
 -----------------------------------------------
 
 -----------------------------------------------
-notAsPolyAsSigErr sig_tau mono_tyvars sty
-  = ppHang (ppPStr SLIT("A type signature is more polymorphic than the inferred type"))
-       4  (ppAboves [ppStr "Some type variables in the inferred type can't be forall'd, namely:",
-                     interpp'SP sty mono_tyvars,
-                     ppPStr SLIT("Possible cause: the RHS mentions something subject to the monomorphism restriction")
-                    ])
+sigContextsErr = ptext SLIT("Mismatched contexts")
 
 
------------------------------------------------
-badMatchErr sig_ty inferred_ty sty
-  = ppHang (ppPStr SLIT("Type signature doesn't match inferred type"))
-        4 (ppAboves [ppHang (ppPStr SLIT("Signature:")) 4 (ppr sty sig_ty),
-                     ppHang (ppPStr SLIT("Inferred :")) 4 (ppr sty inferred_ty)
-          ])
+sigContextsCtxt s1 s2
+  = vcat [ptext SLIT("When matching the contexts of the signatures for"), 
+         nest 2 (vcat [ppr s1 <+> dcolon <+> ppr (idType s1),
+                       ppr s2 <+> dcolon <+> ppr (idType s2)]),
+         ptext SLIT("The signature contexts in a mutually recursive group should all be identical")]
 
 -----------------------------------------------
 
 -----------------------------------------------
-sigCtxt id sty 
-  = ppSep [ppPStr SLIT("When checking signature for"), ppr sty id]
-sigsCtxt ids sty 
-  = ppSep [ppPStr SLIT("When checking signature(s) for:"), interpp'SP sty ids]
+unliftedBindErr flavour mbind
+  = hang (text flavour <+> ptext SLIT("bindings for unlifted types aren't allowed:"))
+        4 (ppr mbind)
 
 -----------------------------------------------
 
 -----------------------------------------------
-sigContextsErr ty_sigs sty
-  = ppHang (ppPStr SLIT("A group of type signatures have mismatched contexts"))
-        4 (ppAboves (map ppr_tc_ty_sig ty_sigs))
-  where
-    ppr_tc_ty_sig (TySigInfo val _ tyvars theta tau_ty _)
-      = ppHang (ppBeside (ppr sty val) (ppPStr SLIT(" :: ")))
-            4 (if null theta
-               then ppNil
-               else ppBesides [ppChar '(', 
-                               ppIntersperse (ppStr ", ") (map (ppr_inst sty) theta), 
-                               ppStr ") => ..."])
-    ppr_inst sty (clas, ty) = ppCat [ppr sty clas, ppr sty ty]
+existentialExplode mbinds
+  = hang (vcat [text "My brain just exploded.",
+               text "I can't handle pattern bindings for existentially-quantified constructors.",
+               text "In the binding group"])
+       4 (ppr mbinds)
 
 -----------------------------------------------
 
 -----------------------------------------------
-specGroundnessCtxt
-  = panic "specGroundnessCtxt"
-
---------------------------------------------
-specContextGroundnessCtxt -- err_ctxt dicts sty
-  = panic "specContextGroundnessCtxt"
-{-
-  = ppHang (
-       ppSep [ppBesides [ppPStr SLIT("In the SPECIALIZE pragma for `"), ppr sty name, ppChar '\''],
-              ppBesides [ppPStr SLIT(" specialised to the type `"), ppr sty spec_ty,  ppChar '\''],
-              pp_spec_id sty,
-              ppPStr SLIT("... not all overloaded type variables were instantiated"),
-              ppPStr SLIT("to ground types:")])
-      4 (ppAboves [ppCat [ppr sty c, ppr sty t]
-                 | (c,t) <- map getDictClassAndType dicts])
-  where
-    (name, spec_ty, locn, pp_spec_id)
-      = case err_ctxt of
-         ValSpecSigCtxt    n ty loc      -> (n, ty, loc, \ x -> ppNil)
-         ValSpecSpecIdCtxt n ty spec loc ->
-           (n, ty, loc,
-            \ sty -> ppBesides [ppPStr SLIT("... type of explicit id `"), ppr sty spec, ppChar '\''])
--}
+restrictedBindCtxtErr binder_names
+  = hang (ptext SLIT("Illegal overloaded type signature(s)"))
+       4 (vcat [ptext SLIT("in a binding group for") <+> pprBinders binder_names,
+               ptext SLIT("that falls under the monomorphism restriction")])
+
+genCtxt binder_names
+  = ptext SLIT("When generalising the type(s) for") <+> pprBinders binder_names
+
+-- Used in error messages
+-- Use quotes for a single one; they look a bit "busy" for several
+pprBinders [bndr] = quotes (ppr bndr)
+pprBinders bndrs  = pprWithCommas ppr bndrs
 \end{code}
 \end{code}
-
-
-
-