[project @ 2004-11-09 13:28:13 by simonpj]

[ghc-hetmet.git] / ghc / compiler / rename / RnSource.lhs

diff --git a/ghc/compiler/rename/RnSource.lhs b/ghc/compiler/rename/RnSource.lhs
index fbcae1c..6ee9f8a 100644 (file)
--- a/ghc/compiler/rename/RnSource.lhs
+++ b/ghc/compiler/rename/RnSource.lhs
@@ -4,260 +4,316 @@
 \section[RnSource]{Main pass of renamer}
 
 \begin{code}
 \section[RnSource]{Main pass of renamer}
 
 \begin{code}

-module RnSource ( rnIfaceDecl, rnSourceDecls, rnHsType, rnHsSigType ) where
+module RnSource ( 
+       rnSrcDecls, addTcgDUs, 
+       rnTyClDecls, checkModDeprec,
+       rnBindGroups, rnBindGroupsAndThen, rnSplice
+    ) where

 
 #include "HsVersions.h"
 
 
 #include "HsVersions.h"
 

-import RnExpr

 import HsSyn
 import HsSyn

-import HsDecls         ( HsIdInfo(..), HsStrictnessInfo(..) )
-import HsPragmas
-import HsTypes         ( getTyVarName, pprClassAssertion, cmpHsTypes )
-import RdrName         ( RdrName, isRdrDataCon, rdrNameOcc )
-import RdrHsSyn                ( RdrNameContext, RdrNameHsType, RdrNameConDecl,
-                         extractHsTyVars
-                       )
+import RdrName         ( RdrName, isRdrDataCon, rdrNameOcc, elemLocalRdrEnv )
+import RdrHsSyn                ( extractGenericPatTyVars )

 import RnHsSyn
 import RnHsSyn

-import HsCore
-
-import RnBinds         ( rnTopBinds, rnMethodBinds, renameSigs )
-import RnEnv           ( bindTyVarsRn, lookupBndrRn, lookupOccRn, 
-                         lookupImplicitOccRn, addImplicitOccRn,
-                         bindLocalsRn, 
-                         bindTyVarsFVRn, bindTyVarsFV2Rn, extendTyVarEnvFVRn,
-                         checkDupOrQualNames, checkDupNames,
-                         newLocallyDefinedGlobalName, newImportedGlobalName, 
-                         newImportedGlobalFromRdrName,
-                         newDFunName,
-                         FreeVars, emptyFVs, plusFV, plusFVs, unitFV, addOneFV
+import RnExpr          ( rnLExpr, checkTH )
+import RnTypes         ( rnLHsType, rnLHsTypes, rnHsSigType, rnHsTypeFVs, rnContext )
+import RnBinds         ( rnTopBinds, rnBinds, rnMethodBinds, 
+                         rnBindsAndThen, renameSigs, checkSigs )
+import RnEnv           ( lookupTopBndrRn, lookupTopFixSigNames,
+                         lookupLocatedTopBndrRn, lookupLocatedOccRn,
+                         lookupOccRn, newLocalsRn, 
+                         bindLocatedLocalsFV, bindPatSigTyVarsFV,
+                         bindTyVarsRn, extendTyVarEnvFVRn,
+                         bindLocalNames, newIPNameRn,
+                         checkDupNames, mapFvRn,
+                         unknownNameErr

                        )
                        )

-import RnMonad
+import TcRnMonad

 
 

-import Name            ( Name, OccName,
-                         ExportFlag(..), Provenance(..), 
-                         nameOccName, NamedThing(..),
-                         mkDefaultMethodOcc, mkDFunOcc
-                       )
+import BasicTypes      ( TopLevelFlag(..)  )
+import HscTypes                ( FixityEnv, FixItem(..),
+                         Deprecations, Deprecs(..), DeprecTxt, plusDeprecs )
+import Class           ( FunDep )
+import Name            ( Name, nameOccName )

 import NameSet
 import NameSet

-import BasicTypes      ( TopLevelFlag(..) )
-import TysWiredIn      ( tupleTyCon, unboxedTupleTyCon, listTyCon )
-import Type            ( funTyCon )
-import FiniteMap       ( elemFM )
-import PrelInfo                ( derivingOccurrences, numClass_RDR, 
-                         deRefStablePtr_NAME, makeStablePtr_NAME,
-                         bindIO_NAME
-                       )
-import Bag             ( bagToList )
-import List            ( partition )
+import NameEnv

 import Outputable
 import Outputable

-import SrcLoc          ( SrcLoc )
-import CmdLineOpts     ( opt_WarnUnusedMatches )       -- Warn of unused for-all'd tyvars
-import UniqFM          ( lookupUFM )
-import Maybes          ( maybeToBool, catMaybes )
-import Util
+import SrcLoc          ( Located(..), unLoc, getLoc, noLoc )
+import CmdLineOpts     ( DynFlag(..) )
+                               -- Warn of unused for-all'd tyvars
+import Maybes          ( seqMaybe )
+import Maybe            ( catMaybes, isNothing )

 \end{code}
 
 \end{code}
 

-rnDecl `renames' declarations.
+@rnSourceDecl@ `renames' declarations.

 It simultaneously performs dependency analysis and precedence parsing.
 It also does the following error checks:
 \begin{enumerate}
 \item
 Checks that tyvars are used properly. This includes checking
 for undefined tyvars, and tyvars in contexts that are ambiguous.
 It simultaneously performs dependency analysis and precedence parsing.
 It also does the following error checks:
 \begin{enumerate}
 \item
 Checks that tyvars are used properly. This includes checking
 for undefined tyvars, and tyvars in contexts that are ambiguous.

+(Some of this checking has now been moved to module @TcMonoType@,
+since we don't have functional dependency information at this point.)

 \item
 Checks that all variable occurences are defined.
 \item 
 \item
 Checks that all variable occurences are defined.
 \item 

-Checks the (..) etc constraints in the export list.
+Checks the @(..)@ etc constraints in the export list.

 \end{enumerate}
 
 
 \end{enumerate}
 
 

+\begin{code}
+rnSrcDecls :: HsGroup RdrName -> RnM (TcGblEnv, HsGroup Name)
+
+rnSrcDecls (HsGroup { hs_valds  = [HsBindGroup binds sigs _],
+                     hs_tyclds = tycl_decls,
+                     hs_instds = inst_decls,
+                     hs_fixds  = fix_decls,
+                     hs_depds  = deprec_decls,
+                     hs_fords  = foreign_decls,
+                     hs_defds  = default_decls,
+                     hs_ruleds = rule_decls })
+
+ = do {                -- Deal with deprecations (returns only the extra deprecations)
+       deprecs <- rnSrcDeprecDecls deprec_decls ;
+       updGblEnv (\gbl -> gbl { tcg_deprecs = tcg_deprecs gbl `plusDeprecs` deprecs })
+                 $ do {
+
+               -- Deal with top-level fixity decls 
+               -- (returns the total new fixity env)
+       fix_env <- rnSrcFixityDecls fix_decls ;
+       updGblEnv (\gbl -> gbl { tcg_fix_env = fix_env })
+                 $ do {
+
+               -- Rename other declarations
+       traceRn (text "Start rnmono") ;
+       (rn_val_decls, bind_dus) <- rnTopBinds binds sigs ;
+       traceRn (text "finish rnmono" <+> ppr rn_val_decls) ;
+
+               -- You might think that we could build proper def/use information
+               -- for type and class declarations, but they can be involved
+               -- in mutual recursion across modules, and we only do the SCC
+               -- analysis for them in the type checker.
+               -- So we content ourselves with gathering uses only; that
+               -- means we'll only report a declaration as unused if it isn't
+               -- mentioned at all.  Ah well.
+       (rn_tycl_decls,    src_fvs1)
+          <- mapFvRn (wrapLocFstM rnTyClDecl) tycl_decls ;
+       (rn_inst_decls,    src_fvs2)
+          <- mapFvRn (wrapLocFstM rnSrcInstDecl) inst_decls ;
+       (rn_rule_decls,    src_fvs3)
+          <- mapFvRn (wrapLocFstM rnHsRuleDecl) rule_decls ;
+       (rn_foreign_decls, src_fvs4)
+          <- mapFvRn (wrapLocFstM rnHsForeignDecl) foreign_decls ;
+       (rn_default_decls, src_fvs5)
+          <- mapFvRn (wrapLocFstM rnDefaultDecl) default_decls ;
+       
+       let {
+          rn_group = HsGroup { hs_valds  = rn_val_decls,
+                               hs_tyclds = rn_tycl_decls,
+                               hs_instds = rn_inst_decls,
+                               hs_fixds  = [],
+                               hs_depds  = [],
+                               hs_fords  = rn_foreign_decls,
+                               hs_defds  = rn_default_decls,
+                               hs_ruleds = rn_rule_decls } ;
+
+          other_fvs = plusFVs [src_fvs1, src_fvs2, src_fvs3, 
+                               src_fvs4, src_fvs5] ;
+          src_dus = bind_dus `plusDU` usesOnly other_fvs 
+               -- Note: src_dus will contain *uses* for locally-defined types
+               -- and classes, but no *defs* for them.  (Because rnTyClDecl 
+               -- returns only the uses.)  This is a little 
+               -- surprising but it doesn't actually matter at all.
+       } ;
+
+       traceRn (text "finish rnSrc" <+> ppr rn_group) ;
+       traceRn (text "finish Dus" <+> ppr src_dus ) ;
+       tcg_env <- getGblEnv ;
+       return (tcg_env `addTcgDUs` src_dus, rn_group)
+    }}}
+
+rnTyClDecls :: [LTyClDecl RdrName] -> RnM [LTyClDecl Name]
+rnTyClDecls tycl_decls = do 
+  (decls', fvs) <- mapFvRn (wrapLocFstM rnTyClDecl) tycl_decls
+  return decls'
+
+addTcgDUs :: TcGblEnv -> DefUses -> TcGblEnv 
+addTcgDUs tcg_env dus = tcg_env { tcg_dus = tcg_dus tcg_env `plusDU` dus }
+\end{code}
+
+

 %*********************************************************
 %*********************************************************

-%*                                                     *
-\subsection{Value declarations}
-%*                                                     *
+%*                                                      *
+       Source-code fixity declarations
+%*                                                      *

 %*********************************************************
 
 \begin{code}
 %*********************************************************
 
 \begin{code}

-rnSourceDecls :: [RdrNameHsDecl] -> RnMS s ([RenamedHsDecl], FreeVars)
-       -- The decls get reversed, but that's ok
-
-rnSourceDecls decls
-  = go emptyFVs [] decls
+rnSrcFixityDecls :: [LFixitySig RdrName] -> RnM FixityEnv
+rnSrcFixityDecls fix_decls
+  = getGblEnv                                  `thenM` \ gbl_env ->
+    foldlM rnFixityDecl (tcg_fix_env gbl_env) 
+           fix_decls                                   `thenM` \ fix_env ->
+    traceRn (text "fixity env" <+> pprFixEnv fix_env)  `thenM_`
+    returnM fix_env
+
+rnFixityDecl :: FixityEnv -> LFixitySig RdrName -> RnM FixityEnv
+rnFixityDecl fix_env (L loc (FixitySig rdr_name fixity))
+  = setSrcSpan loc $
+        -- GHC extension: look up both the tycon and data con 
+       -- for con-like things
+       -- If neither are in scope, report an error; otherwise
+       -- add both to the fixity env
+     addLocM lookupTopFixSigNames rdr_name     `thenM` \ names ->
+     if null names then
+         addLocErr rdr_name unknownNameErr     `thenM_`
+         returnM fix_env
+     else
+         foldlM add fix_env names

   where
   where

-       -- Fixity decls have been dealt with already; ignore them
-    go fvs ds' []          = returnRn (ds', fvs)
-    go fvs ds' (FixD _:ds) = go fvs ds' ds
-    go fvs ds' (d:ds)      = rnDecl d  `thenRn` \(d', fvs') ->
-                            go (fvs `plusFV` fvs') (d':ds') ds
-
-rnIfaceDecl :: RdrNameHsDecl -> RnMS s RenamedHsDecl
-rnIfaceDecl d
-  = rnDecl d   `thenRn` \ (d', fvs) ->
-    returnRn d'
+    add fix_env name
+      = case lookupNameEnv fix_env name of
+          Just (FixItem _ _ loc') 
+                 -> addLocErr rdr_name (dupFixityDecl loc')    `thenM_`
+                    returnM fix_env
+         Nothing -> returnM (extendNameEnv fix_env name fix_item)
+      where
+       fix_item = FixItem (nameOccName name) fixity (getLoc rdr_name)
+
+pprFixEnv :: FixityEnv -> SDoc
+pprFixEnv env 
+  = pprWithCommas (\ (FixItem n f _) -> ppr f <+> ppr n)
+                 (nameEnvElts env)
+
+dupFixityDecl loc rdr_name
+  = vcat [ptext SLIT("Multiple fixity declarations for") <+> quotes (ppr rdr_name),
+         ptext SLIT("also at ") <+> ppr loc
+       ]

 \end{code}
 
 
 %*********************************************************
 \end{code}
 
 
 %*********************************************************

-%*                                                     *
-\subsection{Value declarations}
-%*                                                     *
+%*                                                      *
+       Source-code deprecations declarations
+%*                                                      *

 %*********************************************************
 
 %*********************************************************
 

-\begin{code}
--- rnDecl does all the work
-rnDecl :: RdrNameHsDecl -> RnMS s (RenamedHsDecl, FreeVars)
-
-rnDecl (ValD binds) = rnTopBinds binds `thenRn` \ (new_binds, fvs) ->
-                     returnRn (ValD new_binds, fvs)
+For deprecations, all we do is check that the names are in scope.
+It's only imported deprecations, dealt with in RnIfaces, that we
+gather them together.

 
 

+\begin{code}
+rnSrcDeprecDecls :: [LDeprecDecl RdrName] -> RnM Deprecations
+rnSrcDeprecDecls [] 
+  = returnM NoDeprecs

 
 

-rnDecl (SigD (IfaceSig name ty id_infos loc))
-  = pushSrcLocRn loc $
-    lookupBndrRn name          `thenRn` \ name' ->
-    rnIfaceType doc_str ty     `thenRn` \ ty' ->
-
-       -- Get the pragma info (if any).
-    setModeRn (InterfaceMode Optional)                 $
-       -- In all the rest of the signature we read in optional mode,
-       -- so that (a) we don't die
-    mapRn rnIdInfo id_infos    `thenRn` \ id_infos' -> 
-    returnRn (SigD (IfaceSig name' ty' id_infos' loc), emptyFVs)
-               -- Don't need free-var info for iface binds
-  where
-    doc_str = text "the interface signature for" <+> quotes (ppr name)
+rnSrcDeprecDecls decls
+  = mappM (addLocM rn_deprec) decls    `thenM` \ pairs ->
+    returnM (DeprecSome (mkNameEnv (catMaybes pairs)))
+ where
+   rn_deprec (Deprecation rdr_name txt)
+     = lookupTopBndrRn rdr_name        `thenM` \ name ->
+       returnM (Just (name, (rdrNameOcc rdr_name, txt)))
+
+checkModDeprec :: Maybe DeprecTxt -> Deprecations
+-- Check for a module deprecation; done once at top level
+checkModDeprec Nothing    = NoDeprecs
+checkModDeprec (Just txt) = DeprecAll txt

 \end{code}
 
 %*********************************************************
 %*                                                     *
 \end{code}
 
 %*********************************************************
 %*                                                     *

-\subsection{Type declarations}
+\subsection{Source code declarations}

 %*                                                     *
 %*********************************************************
 
 %*                                                     *
 %*********************************************************
 

-@rnTyDecl@ uses the `global name function' to create a new type
-declaration in which local names have been replaced by their original
-names, reporting any unknown names.
-
-Renaming type variables is a pain. Because they now contain uniques,
-it is necessary to pass in an association list which maps a parsed
-tyvar to its Name representation. In some cases (type signatures of
-values), it is even necessary to go over the type first in order to
-get the set of tyvars used by it, make an assoc list, and then go over
-it again to rename the tyvars! However, we can also do some scoping
-checks at the same time.
-

 \begin{code}
 \begin{code}

-rnDecl (TyClD (TyData new_or_data context tycon tyvars condecls derivings pragmas src_loc))
-  = pushSrcLocRn src_loc $
-    lookupBndrRn tycon                                 `thenRn` \ tycon' ->
-    bindTyVarsFVRn data_doc tyvars                     $ \ tyvars' ->
-    rnContext data_doc context                                 `thenRn` \ (context', cxt_fvs) ->
-    checkDupOrQualNames data_doc con_names             `thenRn_`
-    mapAndUnzipRn rnConDecl condecls                   `thenRn` \ (condecls', con_fvs_s) ->
-    rnDerivs derivings                                 `thenRn` \ (derivings', deriv_fvs) ->
-    ASSERT(isNoDataPragmas pragmas)
-    returnRn (TyClD (TyData new_or_data context' tycon' tyvars' condecls' derivings' noDataPragmas src_loc),
-             cxt_fvs `plusFV` plusFVs con_fvs_s `plusFV` deriv_fvs)
-  where
-    data_doc = text "the data type declaration for" <+> quotes (ppr tycon)
-    con_names = map conDeclName condecls
-
-rnDecl (TyClD (TySynonym name tyvars ty src_loc))
-  = pushSrcLocRn src_loc $
-    lookupBndrRn name                          `thenRn` \ name' ->
-    bindTyVarsFVRn syn_doc tyvars              $ \ tyvars' ->
-    rnHsType syn_doc ty                                `thenRn` \ (ty', ty_fvs) ->
-    returnRn (TyClD (TySynonym name' tyvars' ty' src_loc), ty_fvs)
+rnDefaultDecl (DefaultDecl tys)
+  = mapFvRn (rnHsTypeFVs doc_str) tys  `thenM` \ (tys', fvs) ->
+    returnM (DefaultDecl tys', fvs)

   where
   where

-    syn_doc = text "the declaration for type synonym" <+> quotes (ppr name)
-
-rnDecl (TyClD (ClassDecl context cname tyvars sigs mbinds pragmas tname dname src_loc))
-  = pushSrcLocRn src_loc $
-
-    lookupBndrRn cname                                 `thenRn` \ cname' ->
-
-       -- Deal with the implicit tycon and datacon name
-       -- They aren't in scope (because they aren't visible to the user)
-       -- and what we want to do is simply look them up in the cache;
-       -- we jolly well ought to get a 'hit' there!
-       -- So the 'Imported' part of this call is not relevant. 
-       -- Unclean; but since these two are the only place this happens
-       -- I can't work up the energy to do it more beautifully
-    newImportedGlobalFromRdrName tname                 `thenRn` \ tname' ->
-    newImportedGlobalFromRdrName dname                 `thenRn` \ dname' ->
+    doc_str = text "In a `default' declaration"
+\end{code}

 
 

-       -- Tyvars scope over bindings and context
-    bindTyVarsFV2Rn cls_doc tyvars                     ( \ clas_tyvar_names tyvars' ->
+%*********************************************************
+%*                                                     *
+               Bindings
+%*                                                     *
+%*********************************************************

 
 

-       -- Check the superclasses
-    rnContext cls_doc context                          `thenRn` \ (context', cxt_fvs) ->
+These chaps are here, rather than in TcBinds, so that there
+is just one hi-boot file (for RnSource).  rnSrcDecls is part
+of the loop too, and it must be defined in this module.

 
 

-       -- Check the signatures
-    let
-               -- Filter out fixity signatures;
-               -- they are done at top level
-         nofix_sigs = nonFixitySigs sigs
-    in
-    checkDupOrQualNames sig_doc sig_rdr_names_w_locs           `thenRn_` 
-    mapAndUnzipRn (rn_op cname' clas_tyvar_names) nofix_sigs   `thenRn` \ (sigs', sig_fvs_s) ->
+\begin{code}
+rnBindGroups :: [HsBindGroup RdrName] -> RnM ([HsBindGroup Name], DefUses)
+-- This version assumes that the binders are already in scope
+-- It's used only in 'mdo'
+rnBindGroups []
+   = returnM ([], emptyDUs)
+rnBindGroups [HsBindGroup bind sigs _]
+   = rnBinds NotTopLevel bind sigs
+rnBindGroups b@[HsIPBinds bind]
+   = do addErr (badIpBinds b)  
+       returnM ([], emptyDUs)
+rnBindGroups _
+   = panic "rnBindGroups"
+
+rnBindGroupsAndThen 
+  :: [HsBindGroup RdrName]
+  -> ([HsBindGroup Name] -> RnM (result, FreeVars))
+  -> RnM (result, FreeVars)
+-- This version (a) assumes that the binding vars are not already in scope
+--             (b) removes the binders from the free vars of the thing inside
+-- The parser doesn't produce ThenBinds
+rnBindGroupsAndThen [] thing_inside
+  = thing_inside []
+rnBindGroupsAndThen [HsBindGroup bind sigs _] thing_inside
+  = rnBindsAndThen bind sigs $ \ groups -> thing_inside groups
+rnBindGroupsAndThen [HsIPBinds binds] thing_inside
+  = rnIPBinds binds                    `thenM` \ (binds',fv_binds) ->
+    thing_inside [HsIPBinds binds']    `thenM` \ (thing, fvs_thing) ->
+    returnM (thing, fvs_thing `plusFV` fv_binds)
+
+rnIPBinds [] = returnM ([], emptyFVs)
+rnIPBinds (bind : binds)
+  = wrapLocFstM rnIPBind bind  `thenM` \ (bind', fvBind) ->
+    rnIPBinds binds            `thenM` \ (binds',fvBinds) ->
+    returnM (bind' : binds', fvBind `plusFV` fvBinds)
+
+rnIPBind (IPBind n expr)
+  = newIPNameRn  n             `thenM` \ name ->
+    rnLExpr expr               `thenM` \ (expr',fvExpr) ->
+    return (IPBind name expr', fvExpr)
+
+badIpBinds binds
+  = hang (ptext SLIT("Implicit-parameter bindings illegal in 'mdo':")) 4
+        (ppr binds)
+\end{code}

 
 

-       -- Check the methods
-    checkDupOrQualNames meth_doc meth_rdr_names_w_locs `thenRn_`
-    rnMethodBinds mbinds                               `thenRn` \ (mbinds', meth_fvs) ->

 
 

-       -- Typechecker is responsible for checking that we only
-       -- give default-method bindings for things in this class.
-       -- The renamer *could* check this for class decls, but can't
-       -- for instance decls.
+%*********************************************************
+%*                                                     *
+\subsection{Foreign declarations}
+%*                                                     *
+%*********************************************************

 
 

-    ASSERT(isNoClassPragmas pragmas)
-    returnRn (TyClD (ClassDecl context' cname' tyvars' sigs' mbinds' NoClassPragmas tname' dname' src_loc),
-             plusFVs sig_fvs_s `plusFV` cxt_fvs `plusFV` meth_fvs)
-    )
-  where
-    cls_doc  = text "the declaration for class"        <+> ppr cname
-    sig_doc  = text "the signatures for class"         <+> ppr cname
-    meth_doc = text "the default-methods for class"    <+> ppr cname
-
-    sig_rdr_names_w_locs  = [(op,locn) | ClassOpSig op _ _ locn <- sigs]
-    meth_rdr_names_w_locs = bagToList (collectMonoBinders mbinds)
-    meth_rdr_names       = map fst meth_rdr_names_w_locs
-
-    rn_op clas clas_tyvars sig@(ClassOpSig op maybe_dm ty locn)
-      = pushSrcLocRn locn $
-       lookupBndrRn op                         `thenRn` \ op_name ->
-
-               -- Check the signature
-       rnHsSigType (quotes (ppr op)) ty        `thenRn` \ (new_ty, op_ty_fvs)  ->
-       let
-           check_in_op_ty clas_tyvar = checkRn (clas_tyvar `elemNameSet` op_ty_fvs)
-                                               (classTyVarNotInOpTyErr clas_tyvar sig)
-       in
-        mapRn check_in_op_ty clas_tyvars                `thenRn_`
-
-               -- Make the default-method name
-       let
-           dm_occ = mkDefaultMethodOcc (rdrNameOcc op)
-       in
-       getModuleRn                     `thenRn` \ mod_name ->
-       getModeRn                       `thenRn` \ mode ->
-       (case (mode, maybe_dm) of 
-           (SourceMode, _) | op `elem` meth_rdr_names
-               ->      -- There's an explicit method decl
-                  newLocallyDefinedGlobalName mod_name dm_occ 
-                                              (\_ -> Exported) locn    `thenRn` \ dm_name ->
-                  returnRn (Just dm_name)
-
-           (InterfaceMode _, Just _) 
-               ->      -- Imported class that has a default method decl
-                   newImportedGlobalName mod_name dm_occ       `thenRn` \ dm_name ->
-                   addOccurrenceName dm_name                   `thenRn_`
-                   returnRn (Just dm_name)
-
-           other -> returnRn Nothing
-       )                                       `thenRn` \ maybe_dm_name ->
-
-
-       returnRn (ClassOpSig op_name maybe_dm_name new_ty locn, op_ty_fvs)
+\begin{code}
+rnHsForeignDecl (ForeignImport name ty spec isDeprec)
+  = lookupLocatedTopBndrRn name                `thenM` \ name' ->
+    rnHsTypeFVs (fo_decl_msg name) ty  `thenM` \ (ty', fvs) ->
+    returnM (ForeignImport name' ty' spec isDeprec, fvs)
+
+rnHsForeignDecl (ForeignExport name ty spec isDeprec)
+  = lookupLocatedOccRn name            `thenM` \ name' ->
+    rnHsTypeFVs (fo_decl_msg name) ty          `thenM` \ (ty', fvs) ->
+    returnM (ForeignExport name' ty' spec isDeprec, fvs )
+       -- NB: a foreign export is an *occurrence site* for name, so 
+       --     we add it to the free-variable list.  It might, for example,
+       --     be imported from another module
+
+fo_decl_msg name = ptext SLIT("In the foreign declaration for") <+> ppr name

 \end{code}
 
 
 \end{code}
 
 

@@ -268,561 +324,406 @@ rnDecl (TyClD (ClassDecl context cname tyvars sigs mbinds pragmas tname dname sr
 %*********************************************************
 
 \begin{code}
 %*********************************************************
 
 \begin{code}

-rnDecl (InstD (InstDecl inst_ty mbinds uprags maybe_dfun src_loc))
-  = pushSrcLocRn src_loc $
-    rnHsSigType (text "an instance decl") inst_ty      `thenRn` \ (inst_ty', inst_fvs) ->
+rnSrcInstDecl (InstDecl inst_ty mbinds uprags)
+       -- Used for both source and interface file decls
+  = rnHsSigType (text "an instance decl") inst_ty      `thenM` \ inst_ty' ->
+
+       -- Rename the bindings
+       -- The typechecker (not the renamer) checks that all 
+       -- the bindings are for the right class

     let
     let

-       inst_tyvars = case inst_ty' of
-                       HsForAllTy (Just inst_tyvars) _ _ -> inst_tyvars
-                       other                             -> []
+       meth_doc    = text "In the bindings in an instance declaration"
+       meth_names  = collectHsBindLocatedBinders mbinds
+       (inst_tyvars, _, cls,_) = splitHsInstDeclTy (unLoc inst_ty')
+    in
+    checkDupNames meth_doc meth_names  `thenM_`
+    extendTyVarEnvForMethodBinds inst_tyvars (         

        -- (Slightly strangely) the forall-d tyvars scope over
        -- the method bindings too
        -- (Slightly strangely) the forall-d tyvars scope over
        -- the method bindings too

-    in
-    extendTyVarEnvFVRn inst_tyvars             $
-
-       -- Rename the bindings
-       -- NB meth_names can be qualified!
-    checkDupNames meth_doc meth_names          `thenRn_`
-    rnMethodBinds mbinds                       `thenRn` \ (mbinds', meth_fvs) ->
+       rnMethodBinds cls [] mbinds
+    )                                          `thenM` \ (mbinds', meth_fvs) ->
+       -- Rename the prags and signatures.
+       -- Note that the type variables are not in scope here,
+       -- so that      instance Eq a => Eq (T a) where
+       --                      {-# SPECIALISE instance Eq a => Eq (T [a]) #-}
+       -- works OK. 
+       --
+       -- But the (unqualified) method names are in scope

     let 
     let 

-       binders = mkNameSet (map fst (bagToList (collectMonoBinders mbinds')))
+       binders = collectHsBindBinders mbinds'

     in
     in

-    renameSigs NotTopLevel True binders uprags `thenRn` \ (new_uprags, prag_fvs) ->
-    mkDFunName inst_ty' maybe_dfun src_loc     `thenRn` \ dfun_name ->
-    addOccurrenceName dfun_name                        `thenRn_`
-                       -- The dfun is not optional, because we use its version number
-                       -- to identify the version of the instance declaration
-
-       -- The typechecker checks that all the bindings are for the right class.
-    returnRn (InstD (InstDecl inst_ty' mbinds' new_uprags (Just dfun_name) src_loc),
-             inst_fvs `plusFV` meth_fvs `plusFV` prag_fvs)
-  where
-    meth_doc = text "the bindings in an instance declaration"
-    meth_names   = bagToList (collectMonoBinders mbinds)
-\end{code}
+    bindLocalNames binders (renameSigs uprags)                 `thenM` \ uprags' ->
+    checkSigs (okInstDclSig (mkNameSet binders)) uprags'       `thenM_`

 
 

-%*********************************************************
-%*                                                     *
-\subsection{Default declarations}
-%*                                                     *
-%*********************************************************
-
-\begin{code}
-rnDecl (DefD (DefaultDecl tys src_loc))
-  = pushSrcLocRn src_loc $
-    rnHsTypes doc_str tys              `thenRn` \ (tys', fvs) ->
-    lookupImplicitOccRn numClass_RDR   `thenRn_` 
-    returnRn (DefD (DefaultDecl tys' src_loc), fvs)
-  where
-    doc_str = text "a `default' declaration"
+    returnM (InstDecl inst_ty' mbinds' uprags',
+            meth_fvs `plusFV` hsSigsFVs uprags'
+                     `plusFV` extractHsTyNames inst_ty')

 \end{code}
 
 \end{code}
 

-%*********************************************************
-%*                                                     *
-\subsection{Foreign declarations}
-%*                                                     *
-%*********************************************************
+For the method bindings in class and instance decls, we extend the 
+type variable environment iff -fglasgow-exts

 
 \begin{code}
 
 \begin{code}

-rnDecl (ForD (ForeignDecl name imp_exp ty ext_nm cconv src_loc))
-  = pushSrcLocRn src_loc $
-    lookupBndrRn name                  `thenRn` \ name' ->
-    (case imp_exp of
-       FoImport _ | not isDyn -> addImplicitOccRn name'
-       FoLabel    -> addImplicitOccRn name'
-       FoExport   | isDyn ->
-          addImplicitOccRn makeStablePtr_NAME  `thenRn_`
-          addImplicitOccRn deRefStablePtr_NAME `thenRn_`
-          addImplicitOccRn bindIO_NAME         `thenRn_`
-          returnRn name'
-       _ -> returnRn name')                    `thenRn_`
-    rnHsSigType fo_decl_msg ty                 `thenRn` \ (ty', fvs) ->
-    returnRn (ForD (ForeignDecl name' imp_exp ty' ext_nm cconv src_loc), fvs)
- where
-  fo_decl_msg = ptext SLIT("a foreign declaration")
-  isDyn              = isDynamic ext_nm
-
+extendTyVarEnvForMethodBinds tyvars thing_inside
+  = doptM Opt_GlasgowExts                      `thenM` \ opt_GlasgowExts ->
+    if opt_GlasgowExts then
+       extendTyVarEnvFVRn (map hsLTyVarName tyvars) thing_inside
+    else
+       thing_inside

 \end{code}
 
 \end{code}
 

+

 %*********************************************************
 %*                                                     *
 %*********************************************************
 %*                                                     *

-\subsection{Support code for type/data declarations}
+\subsection{Rules}

 %*                                                     *
 %*********************************************************
 
 \begin{code}
 %*                                                     *
 %*********************************************************
 
 \begin{code}

-rnDerivs :: Maybe [RdrName] -> RnMS s (Maybe [Name], FreeVars)
+rnHsRuleDecl (HsRule rule_name act vars lhs rhs)
+  = bindPatSigTyVarsFV (collectRuleBndrSigTys vars)    $

 
 

-rnDerivs Nothing -- derivs not specified
-  = returnRn (Nothing, emptyFVs)
+    bindLocatedLocalsFV doc (map get_var vars)         $ \ ids ->
+    mapFvRn rn_var (vars `zip` ids)            `thenM` \ (vars', fv_vars) ->

 
 

-rnDerivs (Just ds)
-  = mapRn rn_deriv ds `thenRn` \ derivs ->
-    returnRn (Just derivs, foldl addOneFV emptyFVs derivs)
+    rnLExpr lhs                                        `thenM` \ (lhs', fv_lhs) ->
+    rnLExpr rhs                                        `thenM` \ (rhs', fv_rhs) ->
+    let
+       mb_bad = validRuleLhs ids lhs'
+    in
+    checkErr (isNothing mb_bad)
+            (badRuleLhsErr rule_name lhs' mb_bad)      `thenM_`
+    let
+       bad_vars = [var | var <- ids, not (var `elemNameSet` fv_lhs)]
+    in
+    mappM (addErr . badRuleVar rule_name) bad_vars     `thenM_`
+    returnM (HsRule rule_name act vars' lhs' rhs',
+            fv_vars `plusFV` fv_lhs `plusFV` fv_rhs)

   where
   where

-    rn_deriv clas
-      = lookupOccRn clas           `thenRn` \ clas_name ->
+    doc = text "In the transformation rule" <+> ftext rule_name
+  
+    get_var (RuleBndr v)      = v
+    get_var (RuleBndrSig v _) = v
+
+    rn_var (RuleBndr (L loc v), id)
+       = returnM (RuleBndr (L loc id), emptyFVs)
+    rn_var (RuleBndrSig (L loc v) t, id)
+       = rnHsTypeFVs doc t     `thenM` \ (t', fvs) ->
+         returnM (RuleBndrSig (L loc id) t', fvs)
+\end{code}

 
 

-               -- Now add extra "occurrences" for things that
-               -- the deriving mechanism will later need in order to
-               -- generate code for this class.
-       case lookupUFM derivingOccurrences clas_name of
-               Nothing -> addErrRn (derivingNonStdClassErr clas_name)  `thenRn_`
-                          returnRn clas_name
+Check the shape of a transformation rule LHS.  Currently
+we only allow LHSs of the form @(f e1 .. en)@, where @f@ is
+not one of the @forall@'d variables.  We also restrict the form of the LHS so
+that it may be plausibly matched.  Basically you only get to write ordinary 
+applications.  (E.g. a case expression is not allowed: too elaborate.)

 
 

-               Just occs -> mapRn lookupImplicitOccRn occs     `thenRn_`
-                            returnRn clas_name
-
-\end{code}
+NB: if you add new cases here, make sure you add new ones to TcRule.ruleLhsTvs

 
 \begin{code}
 
 \begin{code}

-conDeclName :: RdrNameConDecl -> (RdrName, SrcLoc)
-conDeclName (ConDecl n _ _ _ l) = (n,l)
-
-rnConDecl :: RdrNameConDecl -> RnMS s (RenamedConDecl, FreeVars)
-rnConDecl (ConDecl name tvs cxt details locn)
-  = pushSrcLocRn locn $
-    checkConName name                  `thenRn_` 
-    lookupBndrRn name                  `thenRn` \ new_name ->
-    bindTyVarsFVRn doc tvs             $ \ new_tyvars ->
-    rnContext doc cxt                  `thenRn` \ (new_context, cxt_fvs) ->
-    rnConDetails doc locn details      `thenRn` \ (new_details, det_fvs) -> 
-    returnRn (ConDecl new_name new_tyvars new_context new_details locn,
-             cxt_fvs `plusFV` det_fvs)
+validRuleLhs :: [Name] -> LHsExpr Name -> Maybe (HsExpr Name)
+-- Nothing => OK
+-- Just e  => Not ok, and e is the offending expression
+validRuleLhs foralls lhs
+  = checkl lhs

   where
   where

-    doc = text "the definition of data constructor" <+> quotes (ppr name)
+    checkl (L loc e) = check e

 
 

-rnConDetails doc locn (VanillaCon tys)
-  = mapAndUnzipRn (rnBangTy doc) tys   `thenRn` \ (new_tys, fvs_s)  ->
-    returnRn (VanillaCon new_tys, plusFVs fvs_s)
+    check (OpApp e1 op _ e2)             = checkl op `seqMaybe` checkl_e e1 `seqMaybe` checkl_e e2
+    check (HsApp e1 e2)                  = checkl e1 `seqMaybe` checkl_e e2
+    check (HsVar v) | v `notElem` foralls = Nothing
+    check other                                  = Just other  -- Failure

 
 

-rnConDetails doc locn (InfixCon ty1 ty2)
-  = rnBangTy doc ty1           `thenRn` \ (new_ty1, fvs1) ->
-    rnBangTy doc ty2           `thenRn` \ (new_ty2, fvs2) ->
-    returnRn (InfixCon new_ty1 new_ty2, fvs1 `plusFV` fvs2)
+    checkl_e (L loc e) = check_e e

 
 

-rnConDetails doc locn (NewCon ty mb_field)
-  = rnHsType doc ty                    `thenRn` \ (new_ty, fvs) ->
-    rn_field mb_field                  `thenRn` \ new_mb_field  ->
-    returnRn (NewCon new_ty new_mb_field, fvs)
-  where
-    rn_field Nothing  = returnRn Nothing
-    rn_field (Just f) =
-       lookupBndrRn f      `thenRn` \ new_f ->
-       returnRn (Just new_f)
-
-rnConDetails doc locn (RecCon fields)
-  = checkDupOrQualNames doc field_names        `thenRn_`
-    mapAndUnzipRn (rnField doc) fields `thenRn` \ (new_fields, fvs_s) ->
-    returnRn (RecCon new_fields, plusFVs fvs_s)
-  where
-    field_names = [(fld, locn) | (flds, _) <- fields, fld <- flds]
-
-rnField doc (names, ty)
-  = mapRn lookupBndrRn names   `thenRn` \ new_names ->
-    rnBangTy doc ty            `thenRn` \ (new_ty, fvs) ->
-    returnRn ((new_names, new_ty), fvs) 
-
-rnBangTy doc (Banged ty)
-  = rnHsType doc ty            `thenRn` \ (new_ty, fvs) ->
-    returnRn (Banged new_ty, fvs)
+    check_e (HsVar v)     = Nothing
+    check_e (HsPar e)    = checkl_e e
+    check_e (HsLit e)    = Nothing
+    check_e (HsOverLit e) = Nothing

 
 

-rnBangTy doc (Unbanged ty)
-  = rnHsType doc ty            `thenRn` \ (new_ty, fvs) ->
-    returnRn (Unbanged new_ty, fvs)
+    check_e (OpApp e1 op _ e2)          = checkl_e e1 `seqMaybe` checkl_e op `seqMaybe` checkl_e e2
+    check_e (HsApp e1 e2)               = checkl_e e1 `seqMaybe` checkl_e e2
+    check_e (NegApp e _)                = checkl_e e
+    check_e (ExplicitList _ es)         = checkl_es es
+    check_e (ExplicitTuple es _) = checkl_es es
+    check_e other               = Just other   -- Fails

 
 

-rnBangTy doc (Unpacked ty)
-  = rnHsType doc ty            `thenRn` \ (new_ty, fvs) ->
-    returnRn (Unpacked new_ty, fvs)
+    checkl_es es = foldr (seqMaybe . checkl_e) Nothing es

 
 

--- This data decl will parse OK
---     data T = a Int
--- treating "a" as the constructor.
--- It is really hard to make the parser spot this malformation.
--- So the renamer has to check that the constructor is legal
---
--- We can get an operator as the constructor, even in the prefix form:
---     data T = :% Int Int
--- from interface files, which always print in prefix form
+badRuleLhsErr name lhs (Just bad_e)
+  = sep [ptext SLIT("Rule") <+> ftext name <> colon,
+        nest 4 (vcat [ptext SLIT("Illegal expression:") <+> ppr bad_e, 
+                      ptext SLIT("in left-hand side:") <+> ppr lhs])]
+    $$
+    ptext SLIT("LHS must be of form (f e1 .. en) where f is not forall'd")

 
 

-checkConName name
-  = checkRn (isRdrDataCon name)
-           (badDataCon name)
+badRuleVar name var
+  = sep [ptext SLIT("Rule") <+> doubleQuotes (ftext name) <> colon,
+        ptext SLIT("Forall'd variable") <+> quotes (ppr var) <+> 
+               ptext SLIT("does not appear on left hand side")]

 \end{code}
 
 
 %*********************************************************
 %*                                                     *
 \end{code}
 
 
 %*********************************************************
 %*                                                     *

-\subsection{Naming a dfun}
+\subsection{Type, class and iface sig declarations}

 %*                                                     *
 %*********************************************************
 
 %*                                                     *
 %*********************************************************
 

-Make a name for the dict fun for an instance decl
+@rnTyDecl@ uses the `global name function' to create a new type
+declaration in which local names have been replaced by their original
+names, reporting any unknown names.
+
+Renaming type variables is a pain. Because they now contain uniques,
+it is necessary to pass in an association list which maps a parsed
+tyvar to its @Name@ representation.
+In some cases (type signatures of values),
+it is even necessary to go over the type first
+in order to get the set of tyvars used by it, make an assoc list,
+and then go over it again to rename the tyvars!
+However, we can also do some scoping checks at the same time.

 
 \begin{code}
 
 \begin{code}

-mkDFunName :: RenamedHsType    -- Instance type
-           -> Maybe RdrName    -- Dfun thing from decl; Nothing <=> source
-           -> SrcLoc
-           -> RnMS s Name
+rnTyClDecl (ForeignType {tcdLName = name, tcdFoType = fo_type, tcdExtName = ext_name})
+  = lookupLocatedTopBndrRn name                `thenM` \ name' ->
+    returnM (ForeignType {tcdLName = name', tcdFoType = fo_type, tcdExtName = ext_name},
+            emptyFVs)
+
+rnTyClDecl (TyData {tcdND = new_or_data, tcdCtxt = context, tcdLName = tycon,
+                   tcdTyVars = tyvars, tcdCons = condecls, 
+                   tcdKindSig = sig, tcdDerivs = derivs})
+  | is_vanilla -- Normal Haskell data type decl
+  = ASSERT( isNothing sig )    -- In normal H98 form, kind signature on the 
+                               -- data type is syntactically illegal
+    bindTyVarsRn data_doc tyvars               $ \ tyvars' ->
+    do { tycon' <- lookupLocatedTopBndrRn tycon
+       ; context' <- rnContext data_doc context
+       ; (derivs', deriv_fvs) <- rn_derivs derivs
+       ; checkDupNames data_doc con_names
+       ; condecls' <- rnConDecls (unLoc tycon') condecls
+       ; returnM (TyData {tcdND = new_or_data, tcdCtxt = context', tcdLName = tycon',
+                          tcdTyVars = tyvars', tcdKindSig = Nothing, tcdCons = condecls', 
+                          tcdDerivs = derivs'}, 
+                  delFVs (map hsLTyVarName tyvars')    $
+                  extractHsCtxtTyNames context'        `plusFV`
+                  plusFVs (map conDeclFVs condecls') `plusFV`
+                  deriv_fvs) }
+
+  | otherwise  -- GADT
+  = ASSERT( null (unLoc context) )
+    do { tycon' <- lookupLocatedTopBndrRn tycon
+       ; tyvars' <- bindTyVarsRn data_doc tyvars 
+                                 (\ tyvars' -> return tyvars')
+               -- For GADTs, the type variables in the declaration 
+               -- do not scope over the constructor signatures
+               --      data T a where { T1 :: forall b. b-> b }
+       ; (derivs', deriv_fvs) <- rn_derivs derivs
+       ; checkDupNames data_doc con_names
+       ; condecls' <- rnConDecls (unLoc tycon') condecls
+       ; returnM (TyData {tcdND = new_or_data, tcdCtxt = noLoc [], tcdLName = tycon',
+                          tcdTyVars = tyvars', tcdCons = condecls', tcdKindSig = sig,
+                          tcdDerivs = derivs'}, 
+                  plusFVs (map conDeclFVs condecls') `plusFV` deriv_fvs) }

 
 

-mkDFunName inst_ty maybe_df src_loc
-  = newDFunName cl_occ tycon_occ maybe_df src_loc

   where
   where

-    (cl_occ, tycon_occ) = get_key inst_ty
-
-    get_key (HsForAllTy _ _ ty)     = get_key ty
-    get_key (MonoFunTy _ ty)        = get_key ty
-    get_key (MonoDictTy cls (ty:_)) = (nameOccName cls, get_tycon_key ty)
-
-    get_tycon_key (MonoTyVar tv)   = nameOccName (getName tv)
-    get_tycon_key (MonoTyApp ty _) = get_tycon_key ty
-    get_tycon_key (MonoTupleTy tys True)  = getOccName (tupleTyCon        (length tys))
-    get_tycon_key (MonoTupleTy tys False) = getOccName (unboxedTupleTyCon (length tys))
-    get_tycon_key (MonoListTy _)   = getOccName listTyCon
-    get_tycon_key (MonoFunTy _ _)  = getOccName funTyCon
-\end{code}
+    is_vanilla = case condecls of      -- Yuk
+                    []                    -> True
+                    L _ (ConDecl {}) : _  -> True
+                    other                 -> False

 
 

+    data_doc = text "In the data type declaration for" <+> quotes (ppr tycon)
+    con_names = map con_names_helper condecls

 
 

-%*********************************************************
-%*                                                     *
-\subsection{Support code to rename types}
-%*                                                     *
-%*********************************************************
+    con_names_helper (L _ (ConDecl n _ _ _)) = n
+    con_names_helper (L _ (GadtDecl n _)) = n

 
 

-\begin{code}
-rnHsSigType :: SDoc -> RdrNameHsType -> RnMS s (RenamedHsType, FreeVars)
-       -- rnHsSigType is used for source-language type signatures,
-       -- which use *implicit* universal quantification.
-rnHsSigType doc_str ty
-  = rnHsType (text "the type signature for" <+> doc_str) ty
+    rn_derivs Nothing   = returnM (Nothing, emptyFVs)
+    rn_derivs (Just ds) = rnLHsTypes data_doc ds       `thenM` \ ds' -> 
+                         returnM (Just ds', extractHsTyNames_s ds')

     
     

-rnIfaceType :: SDoc -> RdrNameHsType -> RnMS s RenamedHsType
-rnIfaceType doc ty 
- = rnHsType doc ty     `thenRn` \ (ty,_) ->
-   returnRn ty
-
-
-rnForAll doc forall_tyvars ctxt ty
-  = bindTyVarsFVRn doc forall_tyvars                   $ \ new_tyvars ->
-    rnContext doc ctxt                                 `thenRn` \ (new_ctxt, cxt_fvs) ->
-    rnHsType doc ty                                    `thenRn` \ (new_ty, ty_fvs) ->
-    returnRn (mkHsForAllTy new_tyvars new_ctxt new_ty,
-             cxt_fvs `plusFV` ty_fvs)
-
--- Check that each constraint mentions at least one of the forall'd type variables
--- Since the forall'd type variables are a subset of the free tyvars
--- of the tau-type part, this guarantees that every constraint mentions
--- at least one of the free tyvars in ty
-checkConstraints explicit_forall doc forall_tyvars ctxt ty
-   = mapRn check ctxt                  `thenRn` \ maybe_ctxt' ->
-     returnRn (catMaybes maybe_ctxt')
-           -- Remove problem ones, to avoid duplicate error message.
-   where
-     check ct@(_,tys)
-       | forall_mentioned = returnRn (Just ct)
-       | otherwise        = addErrRn (ctxtErr explicit_forall doc forall_tyvars ct ty) `thenRn_`
-                            returnRn Nothing
-        where
-         forall_mentioned = foldr ((||) . any (`elem` forall_tyvars) . extractHsTyVars)
-                            False
-                            tys
-
-
-rnHsType :: SDoc -> RdrNameHsType -> RnMS s (RenamedHsType, FreeVars)
-
-rnHsType doc (HsForAllTy Nothing ctxt ty)
-       -- From source code (no kinds on tyvars)
-       -- Given the signature  C => T  we universally quantify 
-       -- over FV(T) \ {in-scope-tyvars} 
-  = getLocalNameEnv            `thenRn` \ name_env ->
-    let
-       mentioned_tyvars = extractHsTyVars ty
-       forall_tyvars    = filter (not . (`elemFM` name_env)) mentioned_tyvars
-    in
-    checkConstraints False doc forall_tyvars ctxt ty   `thenRn` \ ctxt' ->
-    rnForAll doc (map UserTyVar forall_tyvars) ctxt' ty
-
-rnHsType doc (HsForAllTy (Just forall_tyvars) ctxt ty)
-       -- Explicit quantification.
-       -- Check that the forall'd tyvars are a subset of the
-       -- free tyvars in the tau-type part
-       -- That's only a warning... unless the tyvar is constrained by a 
-       -- context in which case it's an error
-  = let
-       mentioned_tyvars      = extractHsTyVars ty
-       constrained_tyvars    = [tv | (_,tys) <- ctxt,
-                                     ty <- tys,
-                                     tv <- extractHsTyVars ty]
-       dubious_guys          = filter (`notElem` mentioned_tyvars) forall_tyvar_names
-       (bad_guys, warn_guys) = partition (`elem` constrained_tyvars) dubious_guys
-       forall_tyvar_names    = map getTyVarName forall_tyvars
-    in
-    mapRn (forAllErr doc ty) bad_guys                          `thenRn_`
-    mapRn (forAllWarn doc ty) warn_guys                                `thenRn_`
-    checkConstraints True doc forall_tyvar_names ctxt ty       `thenRn` \ ctxt' ->
-    rnForAll doc forall_tyvars ctxt' ty
-
-rnHsType doc (MonoTyVar tyvar)
-  = lookupOccRn tyvar          `thenRn` \ tyvar' ->
-    returnRn (MonoTyVar tyvar', unitFV tyvar')
-
-rnHsType doc (MonoFunTy ty1 ty2)
-  = rnHsType doc ty1   `thenRn` \ (ty1', fvs1) ->
-    rnHsType doc ty2   `thenRn` \ (ty2', fvs2) ->
-    returnRn (MonoFunTy ty1' ty2', fvs1 `plusFV` fvs2)
-
-rnHsType doc (MonoListTy ty)
-  = addImplicitOccRn listTyCon_name            `thenRn_`
-    rnHsType doc ty                            `thenRn` \ (ty', fvs) ->
-    returnRn (MonoListTy ty', fvs `addOneFV` listTyCon_name)
-
-rnHsType doc (MonoTupleTy tys boxed)
-  = addImplicitOccRn tup_con_name      `thenRn_`
-    rnHsTypes doc tys                  `thenRn` \ (tys', fvs) ->
-    returnRn (MonoTupleTy tys' boxed, fvs `addOneFV` tup_con_name)
+rnTyClDecl (TySynonym {tcdLName = name, tcdTyVars = tyvars, tcdSynRhs = ty})
+  = lookupLocatedTopBndrRn name                        `thenM` \ name' ->
+    bindTyVarsRn syn_doc tyvars                $ \ tyvars' ->
+    rnHsTypeFVs syn_doc ty                     `thenM` \ (ty', fvs) ->
+    returnM (TySynonym {tcdLName = name', tcdTyVars = tyvars', 
+                       tcdSynRhs = ty'},
+            delFVs (map hsLTyVarName tyvars') fvs)

   where
   where

-    tup_con_name = tupleTyCon_name boxed (length tys)
-
-rnHsType doc (MonoTyApp ty1 ty2)
-  = rnHsType doc ty1           `thenRn` \ (ty1', fvs1) ->
-    rnHsType doc ty2           `thenRn` \ (ty2', fvs2) ->
-    returnRn (MonoTyApp ty1' ty2', fvs1 `plusFV` fvs2)
-
-rnHsType doc (MonoDictTy clas tys)
-  = lookupOccRn clas           `thenRn` \ clas' ->
-    rnHsTypes doc tys          `thenRn` \ (tys', fvs) ->
-    returnRn (MonoDictTy clas' tys', fvs `addOneFV` clas')
-
-rnHsTypes doc tys
-  = mapAndUnzipRn (rnHsType doc) tys   `thenRn` \ (tys, fvs_s) ->
-    returnRn (tys, plusFVs fvs_s)
-\end{code}
+    syn_doc = text "In the declaration for type synonym" <+> quotes (ppr name)

 
 

+rnTyClDecl (ClassDecl {tcdCtxt = context, tcdLName = cname, 
+                      tcdTyVars = tyvars, tcdFDs = fds, tcdSigs = sigs, 
+                      tcdMeths = mbinds})
+  = lookupLocatedTopBndrRn cname               `thenM` \ cname' ->

 
 

-\begin{code}
-rnContext :: SDoc -> RdrNameContext -> RnMS s (RenamedContext, FreeVars)
+       -- Tyvars scope over superclass context and method signatures
+    bindTyVarsRn cls_doc tyvars                        ( \ tyvars' ->
+       rnContext cls_doc context       `thenM` \ context' ->
+       rnFds cls_doc fds               `thenM` \ fds' ->
+       renameSigs sigs                 `thenM` \ sigs' ->
+       returnM   (tyvars', context', fds', sigs')
+    )  `thenM` \ (tyvars', context', fds', sigs') ->

 
 

-rnContext doc ctxt
-  = mapAndUnzipRn rn_ctxt ctxt         `thenRn` \ (theta, fvs_s) ->
+       -- Check the signatures
+       -- First process the class op sigs (op_sigs), then the fixity sigs (non_op_sigs).

     let
     let

-       (_, dup_asserts) = removeDups cmp_assert theta
+       sig_rdr_names_w_locs   = [op | L _ (Sig op _) <- sigs]

     in
     in

-       -- Check for duplicate assertions
-       -- If this isn't an error, then it ought to be:
-    mapRn (addWarnRn . dupClassAssertWarn theta) dup_asserts   `thenRn_`
+    checkDupNames sig_doc sig_rdr_names_w_locs `thenM_` 
+    checkSigs okClsDclSig sigs'                                `thenM_`
+       -- Typechecker is responsible for checking that we only
+       -- give default-method bindings for things in this class.
+       -- The renamer *could* check this for class decls, but can't
+       -- for instance decls.

 
 

-    returnRn (theta, plusFVs fvs_s)
+       -- The newLocals call is tiresome: given a generic class decl
+       --      class C a where
+       --        op :: a -> a
+       --        op {| x+y |} (Inl a) = ...
+       --        op {| x+y |} (Inr b) = ...
+       --        op {| a*b |} (a*b)   = ...
+       -- we want to name both "x" tyvars with the same unique, so that they are
+       -- easy to group together in the typechecker.  
+    extendTyVarEnvForMethodBinds tyvars' (
+        getLocalRdrEnv                                 `thenM` \ name_env ->
+        let
+            meth_rdr_names_w_locs = collectHsBindLocatedBinders mbinds
+            gen_rdr_tyvars_w_locs = 
+               [ tv | tv <- extractGenericPatTyVars mbinds,
+                     not (unLoc tv `elemLocalRdrEnv` name_env) ]
+        in
+        checkDupNames meth_doc meth_rdr_names_w_locs   `thenM_`
+        newLocalsRn gen_rdr_tyvars_w_locs      `thenM` \ gen_tyvars ->
+        rnMethodBinds (unLoc cname') gen_tyvars mbinds
+    ) `thenM` \ (mbinds', meth_fvs) ->
+
+    returnM (ClassDecl { tcdCtxt = context', tcdLName = cname', tcdTyVars = tyvars',
+                        tcdFDs = fds', tcdSigs = sigs', tcdMeths = mbinds'},
+            delFVs (map hsLTyVarName tyvars')  $
+            extractHsCtxtTyNames context'          `plusFV`
+            plusFVs (map extractFunDepNames (map unLoc fds'))  `plusFV`
+            hsSigsFVs sigs'                        `plusFV`
+            meth_fvs)

   where
   where

-    rn_ctxt (clas, tys)
-      =        lookupOccRn clas                `thenRn` \ clas_name ->
-       rnHsTypes doc tys               `thenRn` \ (tys', fvs) ->
-       returnRn ((clas_name, tys'), fvs `addOneFV` clas_name)
-
-    cmp_assert (c1,tys1) (c2,tys2)
-      = (c1 `compare` c2) `thenCmp` (cmpHsTypes compare tys1 tys2)
+    meth_doc = text "In the default-methods for class" <+> ppr cname
+    cls_doc  = text "In the declaration for class"     <+> ppr cname
+    sig_doc  = text "In the signatures for class"      <+> ppr cname

 \end{code}
 
 \end{code}
 

-

 %*********************************************************
 %*                                                     *
 %*********************************************************
 %*                                                     *

-\subsection{IdInfo}
+\subsection{Support code for type/data declarations}

 %*                                                     *
 %*********************************************************
 
 \begin{code}
 %*                                                     *
 %*********************************************************
 
 \begin{code}

-rnIdInfo (HsStrictness str) = returnRn (HsStrictness str)
-
-rnIdInfo (HsWorker worker cons)
-       -- The sole purpose of the "cons" field is so that we can mark the 
-       -- constructors needed to build the wrapper as "needed", so that their
-       -- data type decl will be slurped in. After that their usefulness is 
-       -- o'er, so we just put in the empty list.
-  = lookupOccRn worker                 `thenRn` \ worker' ->
-    mapRn lookupOccRn cons             `thenRn_` 
-    returnRn (HsWorker worker' [])
-
-rnIdInfo (HsUnfold inline (Just expr)) = rnCoreExpr expr       `thenRn` \ expr' ->
-                                         returnRn (HsUnfold inline (Just expr'))
-rnIdInfo (HsUnfold inline Nothing)     = returnRn (HsUnfold inline Nothing)
-rnIdInfo (HsArity arity)       = returnRn (HsArity arity)
-rnIdInfo (HsUpdate update)     = returnRn (HsUpdate update)
-rnIdInfo (HsNoCafRefs)         = returnRn (HsNoCafRefs)
-rnIdInfo (HsCprInfo cpr_info)  = returnRn (HsCprInfo cpr_info)
-rnIdInfo (HsSpecialise tyvars tys expr)
-  = bindTyVarsRn doc tyvars    $ \ tyvars' ->
-    rnCoreExpr expr            `thenRn` \ expr' ->
-    mapRn (rnIfaceType doc) tys        `thenRn` \ tys' ->
-    returnRn (HsSpecialise tyvars' tys' expr')
-  where
-    doc = text "Specialise in interface pragma"
-\end{code}
-
-UfCore expressions.
-
-\begin{code}
-rnCoreExpr (UfType ty)
-  = rnIfaceType (text "unfolding type") ty     `thenRn` \ ty' ->
-    returnRn (UfType ty')
-
-rnCoreExpr (UfVar v)
-  = lookupOccRn v      `thenRn` \ v' ->
-    returnRn (UfVar v')
-
-rnCoreExpr (UfCon con args) 
-  = rnUfCon con                        `thenRn` \ con' ->
-    mapRn rnCoreExpr args      `thenRn` \ args' ->
-    returnRn (UfCon con' args')
-
-rnCoreExpr (UfTuple con args) 
-  = lookupOccRn con            `thenRn` \ con' ->
-    mapRn rnCoreExpr args      `thenRn` \ args' ->
-    returnRn (UfTuple con' args')
-
-rnCoreExpr (UfApp fun arg)
-  = rnCoreExpr fun             `thenRn` \ fun' ->
-    rnCoreExpr arg             `thenRn` \ arg' ->
-    returnRn (UfApp fun' arg')
-
-rnCoreExpr (UfCase scrut bndr alts) 
-  = rnCoreExpr scrut                   `thenRn` \ scrut' ->
-    bindLocalsRn "a UfCase" [bndr]     $ \ [bndr'] ->
-    mapRn rnCoreAlt alts               `thenRn` \ alts' ->
-    returnRn (UfCase scrut' bndr' alts')
-
-rnCoreExpr (UfNote note expr) 
-  = rnNote note                        `thenRn` \ note' ->
-    rnCoreExpr expr            `thenRn` \ expr' ->
-    returnRn  (UfNote note' expr') 
-
-rnCoreExpr (UfLam bndr body)
-  = rnCoreBndr bndr            $ \ bndr' ->
-    rnCoreExpr body            `thenRn` \ body' ->
-    returnRn (UfLam bndr' body')
-
-rnCoreExpr (UfLet (UfNonRec bndr rhs) body)
-  = rnCoreExpr rhs             `thenRn` \ rhs' ->
-    rnCoreBndr bndr            $ \ bndr' ->
-    rnCoreExpr body            `thenRn` \ body' ->
-    returnRn (UfLet (UfNonRec bndr' rhs') body')
-
-rnCoreExpr (UfLet (UfRec pairs) body)
-  = rnCoreBndrs bndrs          $ \ bndrs' ->
-    mapRn rnCoreExpr rhss      `thenRn` \ rhss' ->
-    rnCoreExpr body            `thenRn` \ body' ->
-    returnRn (UfLet (UfRec (bndrs' `zip` rhss')) body')
+rnConDecls :: Name -> [LConDecl RdrName] -> RnM [LConDecl Name]
+rnConDecls tycon condecls
+  =    -- Check that there's at least one condecl,
+       -- or else we're reading an interface file, or -fglasgow-exts
+    (if null condecls then
+       doptM Opt_GlasgowExts   `thenM` \ glaExts ->
+       checkErr glaExts (emptyConDeclsErr tycon)
+     else returnM ()
+    )                                          `thenM_` 
+    mappM (wrapLocM rnConDecl) condecls
+
+rnConDecl :: ConDecl RdrName -> RnM (ConDecl Name)
+rnConDecl (ConDecl name tvs cxt details)
+  = addLocM checkConName name          `thenM_` 
+    lookupLocatedTopBndrRn name                `thenM` \ new_name ->
+
+    bindTyVarsRn doc tvs               $ \ new_tyvars ->
+    rnContext doc cxt                  `thenM` \ new_context ->
+    rnConDetails doc details           `thenM` \ new_details -> 
+    returnM (ConDecl new_name new_tyvars new_context new_details)

   where
   where

-    (bndrs, rhss) = unzip pairs
-\end{code}
+    doc = text "In the definition of data constructor" <+> quotes (ppr name)

 
 

-\begin{code}
-rnCoreBndr (UfValBinder name ty) thing_inside
-  = rnIfaceType (text str) ty  `thenRn` \ ty' ->
-    bindLocalsRn str [name]    $ \ [name'] ->
-    thing_inside (UfValBinder name' ty')
-  where
-    str = "unfolding id"
-    
-rnCoreBndr (UfTyBinder name kind) thing_inside
-  = bindLocalsRn "an unfolding tyvar" [name] $ \ [name'] ->
-    thing_inside (UfTyBinder name' kind)
-    
-rnCoreBndrs bndrs thing_inside         -- Expect them all to be ValBinders
-  = mapRn (rnIfaceType (text str)) tys `thenRn` \ tys' ->
-    bindLocalsRn str names             $ \ names' ->
-    thing_inside (zipWith UfValBinder names' tys')
+rnConDecl (GadtDecl name ty) 
+  = addLocM checkConName name          `thenM_` 
+    lookupLocatedTopBndrRn name                `thenM` \ new_name ->
+    rnHsSigType doc ty                  `thenM` \ new_ty ->
+    returnM (GadtDecl new_name new_ty)

   where
   where

-    str   = "unfolding id"
-    names = map (\ (UfValBinder name _ ) -> name) bndrs
-    tys   = map (\ (UfValBinder _    ty) -> ty)   bndrs
-\end{code}    
-
-\begin{code}
-rnCoreAlt (con, bndrs, rhs)
-  = rnUfCon con                                        `thenRn` \ con' ->
-    bindLocalsRn "an unfolding alt" bndrs      $ \ bndrs' ->
-    rnCoreExpr rhs                             `thenRn` \ rhs' ->
-    returnRn (con', bndrs', rhs')
-
-
-rnNote (UfCoerce ty)
-  = rnIfaceType (text "unfolding coerce") ty   `thenRn` \ ty' ->
-    returnRn (UfCoerce ty')
+    doc = text "In the definition of data constructor" <+> quotes (ppr name)

 
 

-rnNote (UfSCC cc)   = returnRn (UfSCC cc)
-rnNote UfInlineCall = returnRn UfInlineCall
+rnConDetails doc (PrefixCon tys)
+  = mappM (rnLHsType doc) tys  `thenM` \ new_tys  ->
+    returnM (PrefixCon new_tys)

 
 

+rnConDetails doc (InfixCon ty1 ty2)
+  = rnLHsType doc ty1                  `thenM` \ new_ty1 ->
+    rnLHsType doc ty2                  `thenM` \ new_ty2 ->
+    returnM (InfixCon new_ty1 new_ty2)

 
 

-rnUfCon UfDefault
-  = returnRn UfDefault
+rnConDetails doc (RecCon fields)
+  = checkDupNames doc field_names      `thenM_`
+    mappM (rnField doc) fields         `thenM` \ new_fields ->
+    returnM (RecCon new_fields)
+  where
+    field_names = [fld | (fld, _) <- fields]

 
 

-rnUfCon (UfDataCon con)
-  = lookupOccRn con            `thenRn` \ con' ->
-    returnRn (UfDataCon con')
+rnField doc (name, ty)
+  = lookupLocatedTopBndrRn name        `thenM` \ new_name ->
+    rnLHsType doc ty           `thenM` \ new_ty ->
+    returnM (new_name, new_ty) 

 
 

-rnUfCon (UfLitCon lit)
-  = returnRn (UfLitCon lit)
+-- This data decl will parse OK
+--     data T = a Int
+-- treating "a" as the constructor.
+-- It is really hard to make the parser spot this malformation.
+-- So the renamer has to check that the constructor is legal
+--
+-- We can get an operator as the constructor, even in the prefix form:
+--     data T = :% Int Int
+-- from interface files, which always print in prefix form

 
 

-rnUfCon (UfLitLitCon lit ty)
-  = rnIfaceType (text "litlit") ty             `thenRn` \ ty' ->
-    returnRn (UfLitLitCon lit ty')
+checkConName name = checkErr (isRdrDataCon name) (badDataCon name)

 
 

-rnUfCon (UfPrimOp op)
-  = lookupOccRn op             `thenRn` \ op' ->
-    returnRn (UfPrimOp op')
+badDataCon name
+   = hsep [ptext SLIT("Illegal data constructor name"), quotes (ppr name)]

 
 

-rnUfCon (UfCCallOp str is_dyn casm gc)
-  = returnRn (UfCCallOp str is_dyn casm gc)
+emptyConDeclsErr tycon
+  = sep [quotes (ppr tycon) <+> ptext SLIT("has no constructors"),
+        nest 4 (ptext SLIT("(-fglasgow-exts permits this)"))]

 \end{code}
 
 \end{code}
 

+

 %*********************************************************
 %*                                                     *
 %*********************************************************
 %*                                                     *

-\subsection{Errors}
+\subsection{Support code to rename types}

 %*                                                     *
 %*********************************************************
 
 \begin{code}
 %*                                                     *
 %*********************************************************
 
 \begin{code}

-derivingNonStdClassErr clas
-  = hsep [ptext SLIT("non-standard class"), ppr clas, ptext SLIT("in deriving clause")]
+rnFds :: SDoc -> [Located (FunDep RdrName)] -> RnM [Located (FunDep Name)]
+
+rnFds doc fds
+  = mappM (wrapLocM rn_fds) fds
+  where
+    rn_fds (tys1, tys2)
+      =        rnHsTyVars doc tys1             `thenM` \ tys1' ->
+       rnHsTyVars doc tys2             `thenM` \ tys2' ->
+       returnM (tys1', tys2')

 
 

-classTyVarNotInOpTyErr clas_tyvar sig
-  = hang (hsep [ptext SLIT("Class type variable"),
-                      quotes (ppr clas_tyvar),
-                      ptext SLIT("does not appear in method signature")])
-        4 (ppr sig)
+rnHsTyVars doc tvs  = mappM (rnHsTyvar doc) tvs
+rnHsTyvar doc tyvar = lookupOccRn tyvar
+\end{code}

 
 

-dupClassAssertWarn ctxt (assertion : dups)
-  = sep [hsep [ptext SLIT("Duplicate class assertion"), 
-              quotes (pprClassAssertion assertion),
-              ptext SLIT("in the context:")],
-        nest 4 (pprContext ctxt <+> ptext SLIT("..."))]

 
 

-badDataCon name
-   = hsep [ptext SLIT("Illegal data constructor name"), quotes (ppr name)]
+%*********************************************************
+%*                                                     *
+               Splices
+%*                                                     *
+%*********************************************************

 
 

-forAllWarn doc ty tyvar
-  | not opt_WarnUnusedMatches = returnRn ()
-  | otherwise
-  = addWarnRn (
-      sep [ptext SLIT("The universally quantified type variable") <+> quotes (ppr tyvar),
-          nest 4 (ptext SLIT("does not appear in the type") <+> quotes (ppr ty))]
-      $$
-      (ptext SLIT("In") <+> doc))
-
-forAllErr doc ty tyvar
-  = addErrRn (
-      sep [ptext SLIT("The constrained type variable") <+> quotes (ppr tyvar),
-          nest 4 (ptext SLIT("does not appear in the type") <+> quotes (ppr ty))]
-      $$
-      (ptext SLIT("In") <+> doc))
-
-ctxtErr explicit_forall doc tyvars constraint ty
-  = sep [ptext SLIT("The constraint") <+> quotes (pprClassAssertion constraint) <+>
-                  ptext SLIT("does not mention any of"),
-        if explicit_forall then
-          nest 4 (ptext SLIT("the universally quantified type variables") <+> braces (interpp'SP tyvars))
-        else
-          nest 4 (ptext SLIT("the type variables in the type") <+> quotes (ppr ty))
-    ]
-    $$
-    (ptext SLIT("In") <+> doc)
+\begin{code}
+rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
+rnSplice (HsSplice n expr)
+  = checkTH expr "splice"      `thenM_`
+    getSrcSpanM                `thenM` \ loc ->
+    newLocalsRn [L loc n]      `thenM` \ [n'] ->
+    rnLExpr expr               `thenM` \ (expr', fvs) ->
+    returnM (HsSplice n' expr', fvs)

 \end{code}
 \end{code}