%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[RnSource]{Main pass of renamer}
\begin{code}
-#include "HsVersions.h"
-
-module RnSource ( rnDecl, rnHsType ) where
+module RnSource ( rnTyClDecl, rnIfaceRuleDecl, rnInstDecl, rnSourceDecls,
+ ) where
-IMP_Ubiq()
-IMPORT_DELOOPER(RnLoop) -- *check* the RnPass/RnExpr/RnBinds loop-breaking
+#include "HsVersions.h"
+import RnExpr
import HsSyn
-import HsDecls ( HsIdInfo(..) )
-import HsPragmas
-import HsTypes ( getTyVarName )
-import RdrHsSyn
+import HscTypes ( GlobalRdrEnv, AvailEnv )
+import RdrName ( RdrName, isRdrDataCon, elemRdrEnv )
+import RdrHsSyn ( RdrNameConDecl, RdrNameTyClDecl,
+ extractGenericPatTyVars
+ )
import RnHsSyn
import HsCore
-import RnBinds ( rnTopBinds, rnMethodBinds )
-import RnEnv ( bindTyVarsRn, lookupRn, lookupOccRn, lookupImplicitOccRn, bindLocalsRn,
- lookupOptionalOccRn, newDfunName,
- listType_RDR, tupleType_RDR )
+import RnTypes ( rnHsType, rnHsSigType, rnHsTypeFVs, rnContext )
+
+import RnBinds ( rnTopBinds, rnMethodBinds, renameSigs, renameSigsFVs )
+import RnEnv ( lookupTopBndrRn, lookupOccRn, lookupIfaceName,
+ lookupOrigNames, lookupSysBinder, newLocalsRn,
+ bindLocalsFVRn, bindPatSigTyVars,
+ bindTyVarsRn, bindTyVars2Rn,
+ extendTyVarEnvFVRn,
+ bindCoreLocalRn, bindCoreLocalsRn, bindLocalNames,
+ checkDupOrQualNames, checkDupNames, mapFvRn
+ )
import RnMonad
-import Name ( Name, isLocallyDefined, isTvOcc, pprNonSym,
- Provenance,
- SYN_IE(NameSet), unionNameSets, emptyNameSet, mkNameSet, unitNameSet,
- elemNameSet
+import Class ( FunDep, DefMeth (..) )
+import DataCon ( dataConId )
+import Name ( Name, NamedThing(..) )
+import NameSet
+import PrelInfo ( derivableClassKeys )
+import PrelNames ( deRefStablePtrName, newStablePtrName,
+ bindIOName, returnIOName
)
-import ErrUtils ( addErrLoc, addShortErrLocLine, addShortWarnLocLine )
-import FiniteMap ( emptyFM, lookupFM, addListToFM_C )
-import Id ( GenId{-instance NamedThing-} )
-import IdInfo ( IdInfo, StrictnessInfo(..), FBTypeInfo, DemandInfo, ArgUsageInfo )
-import SpecEnv ( SpecEnv )
-import CoreUnfold ( Unfolding(..), SimpleUnfolding )
-import MagicUFs ( MagicUnfoldingFun )
-import PrelInfo ( derivingOccurrences, evalClass_RDR, numClass_RDR )
-import ListSetOps ( unionLists, minusList )
-import Maybes ( maybeToBool, catMaybes )
-import Bag ( emptyBag, unitBag, consBag, unionManyBags, unionBags, listToBag, bagToList )
-import Outputable ( Outputable(..){-instances-} )
---import PprStyle -- ToDo:rm
-import Pretty
+import TysWiredIn ( tupleCon )
+import List ( partition )
+import Outputable
import SrcLoc ( SrcLoc )
--- import TyCon ( TyCon{-instance NamedThing-} )
-import Unique ( Unique )
-import UniqSet ( SYN_IE(UniqSet) )
-import UniqFM ( UniqFM, lookupUFM )
-import Util ( isIn, isn'tIn, thenCmp, removeDups, cmpPString,
- panic, assertPanic{- , pprTrace ToDo:rm-} )
+import CmdLineOpts ( DynFlag(..) )
+ -- Warn of unused for-all'd tyvars
+import Unique ( Uniquable(..) )
+import Maybes ( maybeToBool )
\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.
+(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
-Checks the (..) etc constraints in the export list.
+Checks the @(..)@ etc constraints in the export list.
\end{enumerate}
%*********************************************************
%* *
-\subsection{Value declarations}
+\subsection{Source code declarations}
%* *
%*********************************************************
\begin{code}
-rnDecl :: RdrNameHsDecl -> RnMS s RenamedHsDecl
+rnSourceDecls :: GlobalRdrEnv -> AvailEnv -> LocalFixityEnv
+ -> [RdrNameHsDecl]
+ -> RnMG ([RenamedHsDecl], FreeVars)
+ -- The decls get reversed, but that's ok
-rnDecl (ValD binds) = rnTopBinds binds `thenRn` \ new_binds ->
- returnRn (ValD new_binds)
+rnSourceDecls gbl_env avails local_fixity_env decls
+ = initRnMS gbl_env avails emptyRdrEnv local_fixity_env SourceMode (go emptyFVs [] decls)
+ where
+ -- Fixity and deprecations 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' (DeprecD _:ds) = go fvs ds' ds
+ go fvs ds' (d:ds) = rnSourceDecl d `thenRn` \(d', fvs') ->
+ go (fvs `plusFV` fvs') (d':ds') ds
-rnDecl (SigD (IfaceSig name ty id_infos loc))
- = pushSrcLocRn loc $
- lookupRn name `thenRn` \ name' ->
- rnHsType ty `thenRn` \ ty' ->
- mapRn rnIdInfo id_infos `thenRn` \ id_infos' ->
- returnRn (SigD (IfaceSig name' ty' id_infos' loc))
-\end{code}
+rnSourceDecl :: RdrNameHsDecl -> RnMS (RenamedHsDecl, FreeVars)
-%*********************************************************
-%* *
-\subsection{Type declarations}
-%* *
-%*********************************************************
+rnSourceDecl (ValD binds) = rnTopBinds binds `thenRn` \ (new_binds, fvs) ->
+ returnRn (ValD new_binds, fvs)
-@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.
+rnSourceDecl (TyClD tycl_decl)
+ = rnTyClDecl tycl_decl `thenRn` \ new_decl ->
+ finishSourceTyClDecl tycl_decl new_decl `thenRn` \ (new_decl', fvs) ->
+ returnRn (TyClD new_decl', fvs `plusFV` tyClDeclFVs new_decl')
-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.
+rnSourceDecl (InstD inst)
+ = rnInstDecl inst `thenRn` \ new_inst ->
+ finishSourceInstDecl inst new_inst `thenRn` \ (new_inst', fvs) ->
+ returnRn (InstD new_inst', fvs `plusFV` instDeclFVs new_inst')
-\begin{code}
-rnDecl (TyD (TyData context tycon tyvars condecls derivings pragmas src_loc))
- = pushSrcLocRn src_loc $
- lookupRn tycon `thenRn` \ tycon' ->
- bindTyVarsRn "data declaration" tyvars $ \ tyvars' ->
- rnContext context `thenRn` \ context' ->
- mapRn rnConDecl condecls `thenRn` \ condecls' ->
- rnDerivs derivings `thenRn` \ derivings' ->
- ASSERT(isNoDataPragmas pragmas)
- returnRn (TyD (TyData context' tycon' tyvars' condecls' derivings' noDataPragmas src_loc))
+rnSourceDecl (RuleD rule)
+ = rnHsRuleDecl rule `thenRn` \ (new_rule, fvs) ->
+ returnRn (RuleD new_rule, fvs)
-rnDecl (TyD (TyNew context tycon tyvars condecl derivings pragmas src_loc))
- = pushSrcLocRn src_loc $
- lookupRn tycon `thenRn` \ tycon' ->
- bindTyVarsRn "newtype declaration" tyvars $ \ tyvars' ->
- rnContext context `thenRn` \ context' ->
- rnConDecl condecl `thenRn` \ condecl' ->
- rnDerivs derivings `thenRn` \ derivings' ->
- ASSERT(isNoDataPragmas pragmas)
- returnRn (TyD (TyNew context' tycon' tyvars' condecl' derivings' noDataPragmas src_loc))
-
-rnDecl (TyD (TySynonym name tyvars ty src_loc))
+rnSourceDecl (ForD ford)
+ = rnHsForeignDecl ford `thenRn` \ (new_ford, fvs) ->
+ returnRn (ForD new_ford, fvs)
+
+rnSourceDecl (DefD (DefaultDecl tys src_loc))
= pushSrcLocRn src_loc $
- lookupRn name `thenRn` \ name' ->
- bindTyVarsRn "type declaration" tyvars $ \ tyvars' ->
- rnHsType ty `thenRn` \ ty' ->
- returnRn (TyD (TySynonym name' tyvars' ty' src_loc))
+ mapFvRn (rnHsTypeFVs doc_str) tys `thenRn` \ (tys', fvs) ->
+ returnRn (DefD (DefaultDecl tys' src_loc), fvs)
+ where
+ doc_str = text "In a `default' declaration"
\end{code}
+
%*********************************************************
%* *
-\subsection{Class declarations}
+\subsection{Foreign declarations}
%* *
%*********************************************************
-@rnClassDecl@ uses the `global name function' to create a new
-class declaration in which local names have been replaced by their
-original names, reporting any unknown names.
-
\begin{code}
-rnDecl (ClD (ClassDecl context cname tyvar sigs mbinds pragmas src_loc))
- = pushSrcLocRn src_loc $
- bindTyVarsRn "class declaration" [tyvar] $ \ [tyvar'] ->
- rnContext context `thenRn` \ context' ->
- lookupRn cname `thenRn` \ cname' ->
- mapRn (rn_op cname' (getTyVarName tyvar')) sigs `thenRn` \ sigs' ->
- rnMethodBinds mbinds `thenRn` \ mbinds' ->
- ASSERT(isNoClassPragmas pragmas)
- returnRn (ClD (ClassDecl context' cname' tyvar' sigs' mbinds' NoClassPragmas src_loc))
+rnHsForeignDecl (ForeignImport name ty spec src_loc)
+ = pushSrcLocRn src_loc $
+ lookupTopBndrRn name `thenRn` \ name' ->
+ rnHsTypeFVs (fo_decl_msg name) ty `thenRn` \ (ty', fvs) ->
+ returnRn (ForeignImport name' ty' spec src_loc, fvs `plusFV` extras spec)
where
- rn_op clas clas_tyvar sig@(ClassOpSig op ty pragmas locn)
- = pushSrcLocRn locn $
- lookupRn op `thenRn` \ op_name ->
- rnHsType ty `thenRn` \ new_ty ->
- let
- (ctxt, op_ty) = case new_ty of
- HsForAllTy tvs ctxt op_ty -> (ctxt, op_ty)
- other -> ([], new_ty)
- ctxt_fvs = extractCtxtTyNames ctxt
- op_ty_fvs = extractHsTyNames op_ty -- Includes tycons/classes but we
- -- don't care about that
- in
- -- check that class tyvar appears in op_ty
- checkRn (clas_tyvar `elemNameSet` op_ty_fvs)
- (classTyVarNotInOpTyErr clas_tyvar sig)
- `thenRn_`
-
- -- check that class tyvar *doesn't* appear in the sig's context
- checkRn (not (clas_tyvar `elemNameSet` ctxt_fvs))
- (classTyVarInOpCtxtErr clas_tyvar sig)
- `thenRn_`
-
- ASSERT(isNoClassOpPragmas pragmas)
- returnRn (ClassOpSig op_name new_ty noClassOpPragmas locn)
+ extras (CDynImport _) = mkFVs [newStablePtrName, deRefStablePtrName, bindIOName, returnIOName]
+ extras other = emptyFVs
+
+rnHsForeignDecl (ForeignExport name ty spec src_loc)
+ = pushSrcLocRn src_loc $
+ lookupOccRn name `thenRn` \ name' ->
+ rnHsTypeFVs (fo_decl_msg name) ty `thenRn` \ (ty', fvs) ->
+ returnRn (ForeignExport name' ty' spec src_loc,
+ mkFVs [bindIOName, returnIOName] `plusFV` fvs)
+
+fo_decl_msg name = ptext SLIT("The foreign declaration for") <+> ppr name
\end{code}
%*********************************************************
\begin{code}
-rnDecl (InstD (InstDecl inst_ty mbinds uprags maybe_dfun_name src_loc))
+rnInstDecl (InstDecl inst_ty mbinds uprags maybe_dfun_rdr_name src_loc)
+ -- Used for both source and interface file decls
= pushSrcLocRn src_loc $
- rnHsType inst_ty `thenRn` \ inst_ty' ->
- rnMethodBinds mbinds `thenRn` \ mbinds' ->
- mapRn rn_uprag uprags `thenRn` \ new_uprags ->
- rn_dfun maybe_dfun_name `thenRn` \ dfun_name' ->
+ rnHsSigType (text "an instance decl") inst_ty `thenRn` \ inst_ty' ->
+
+ (case maybe_dfun_rdr_name of
+ Nothing -> returnRn Nothing
+ Just dfun_rdr_name -> lookupIfaceName dfun_rdr_name `thenRn` \ dfun_name ->
+ returnRn (Just dfun_name)
+ ) `thenRn` \ maybe_dfun_name ->
+
+ -- The typechecker checks that all the bindings are for the right class.
+ returnRn (InstDecl inst_ty' EmptyMonoBinds [] maybe_dfun_name src_loc)
+
+-- Compare finishSourceTyClDecl
+finishSourceInstDecl (InstDecl _ mbinds uprags _ _ )
+ (InstDecl inst_ty _ _ maybe_dfun_name src_loc)
+ -- Used for both source decls only
+ = ASSERT( not (maybeToBool maybe_dfun_name) ) -- Source decl!
+ let
+ meth_doc = text "In the bindings in an instance declaration"
+ meth_names = collectLocatedMonoBinders mbinds
+ (inst_tyvars, (cls,_)) = getHsInstHead inst_ty
+ -- (Slightly strangely) the forall-d tyvars scope over
+ -- the method bindings too
+ in
- returnRn (InstD (InstDecl inst_ty' mbinds' new_uprags dfun_name' src_loc))
- where
- rn_dfun Nothing = newDfunName src_loc `thenRn` \ n' ->
- returnRn (Just n')
- rn_dfun (Just n) = lookupOptionalOccRn n `thenRn` \ n' ->
- returnRn (Just n')
-
- rn_uprag (SpecSig op ty using locn)
- = pushSrcLocRn src_loc $
- lookupRn op `thenRn` \ op_name ->
- rnHsType ty `thenRn` \ new_ty ->
- rn_using using `thenRn` \ new_using ->
- returnRn (SpecSig op_name new_ty new_using locn)
-
- rn_uprag (InlineSig op locn)
- = pushSrcLocRn locn $
- lookupRn op `thenRn` \ op_name ->
- returnRn (InlineSig op_name locn)
-
- rn_uprag (DeforestSig op locn)
- = pushSrcLocRn locn $
- lookupRn op `thenRn` \ op_name ->
- returnRn (DeforestSig op_name locn)
-
- rn_uprag (MagicUnfoldingSig op str locn)
- = pushSrcLocRn locn $
- lookupRn op `thenRn` \ op_name ->
- returnRn (MagicUnfoldingSig op_name str locn)
-
- rn_using Nothing = returnRn Nothing
- rn_using (Just v) = lookupOccRn v `thenRn` \ new_v ->
- returnRn (Just new_v)
+ -- Rename the bindings
+ -- NB meth_names can be qualified!
+ checkDupNames meth_doc meth_names `thenRn_`
+ extendTyVarEnvFVRn (map hsTyVarName inst_tyvars) (
+ rnMethodBinds cls [] mbinds
+ ) `thenRn` \ (mbinds', meth_fvs) ->
+ let
+ binders = collectMonoBinders mbinds'
+ binder_set = mkNameSet binders
+ in
+ -- 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
+ bindLocalNames binders (
+ renameSigsFVs (okInstDclSig binder_set) uprags
+ ) `thenRn` \ (uprags', prag_fvs) ->
+
+ returnRn (InstDecl inst_ty mbinds' uprags' maybe_dfun_name src_loc,
+ meth_fvs `plusFV` prag_fvs)
\end{code}
%*********************************************************
%* *
-\subsection{Default declarations}
+\subsection{Rules}
%* *
%*********************************************************
\begin{code}
-rnDecl (DefD (DefaultDecl tys src_loc))
- = pushSrcLocRn src_loc $
- mapRn rnHsType tys `thenRn` \ tys' ->
- lookupImplicitOccRn numClass_RDR `thenRn_`
- returnRn (DefD (DefaultDecl tys' src_loc))
+rnIfaceRuleDecl (IfaceRule rule_name act vars fn args rhs src_loc)
+ = pushSrcLocRn src_loc $
+ lookupOccRn fn `thenRn` \ fn' ->
+ rnCoreBndrs vars $ \ vars' ->
+ mapRn rnCoreExpr args `thenRn` \ args' ->
+ rnCoreExpr rhs `thenRn` \ rhs' ->
+ returnRn (IfaceRule rule_name act vars' fn' args' rhs' src_loc)
+
+rnIfaceRuleDecl (IfaceRuleOut fn rule) -- Builtin rules come this way
+ = lookupOccRn fn `thenRn` \ fn' ->
+ returnRn (IfaceRuleOut fn' rule)
+
+rnHsRuleDecl (HsRule rule_name act vars lhs rhs src_loc)
+ = pushSrcLocRn src_loc $
+ bindPatSigTyVars (collectRuleBndrSigTys vars) $
+
+ bindLocalsFVRn doc (map get_var vars) $ \ ids ->
+ mapFvRn rn_var (vars `zip` ids) `thenRn` \ (vars', fv_vars) ->
+
+ rnExpr lhs `thenRn` \ (lhs', fv_lhs) ->
+ rnExpr rhs `thenRn` \ (rhs', fv_rhs) ->
+ checkRn (validRuleLhs ids lhs')
+ (badRuleLhsErr rule_name lhs') `thenRn_`
+ let
+ bad_vars = [var | var <- ids, not (var `elemNameSet` fv_lhs)]
+ in
+ mapRn (addErrRn . badRuleVar rule_name) bad_vars `thenRn_`
+ returnRn (HsRule rule_name act vars' lhs' rhs' src_loc,
+ fv_vars `plusFV` fv_lhs `plusFV` fv_rhs)
+ where
+ doc = text "In the transformation rule" <+> ptext rule_name
+
+ get_var (RuleBndr v) = v
+ get_var (RuleBndrSig v _) = v
+
+ rn_var (RuleBndr v, id) = returnRn (RuleBndr id, emptyFVs)
+ rn_var (RuleBndrSig v t, id) = rnHsTypeFVs doc t `thenRn` \ (t', fvs) ->
+ returnRn (RuleBndrSig id t', fvs)
\end{code}
+
%*********************************************************
%* *
-\subsection{Support code for type/data declarations}
+\subsection{Type, class and iface sig declarations}
%* *
%*********************************************************
-\begin{code}
-rnDerivs :: Maybe [RdrName] -> RnMS s (Maybe [Name])
+@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.
-rnDerivs Nothing -- derivs not specified
- = lookupImplicitOccRn evalClass_RDR `thenRn_`
- returnRn Nothing
+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.
-rnDerivs (Just ds)
- = lookupImplicitOccRn evalClass_RDR `thenRn_`
- mapRn rn_deriv ds `thenRn` \ derivs ->
- returnRn (Just derivs)
+\begin{code}
+rnTyClDecl (IfaceSig {tcdName = name, tcdType = ty, tcdIdInfo = id_infos, tcdLoc = loc})
+ = pushSrcLocRn loc $
+ lookupTopBndrRn name `thenRn` \ name' ->
+ rnHsType doc_str ty `thenRn` \ ty' ->
+ mapRn rnIdInfo id_infos `thenRn` \ id_infos' ->
+ returnRn (IfaceSig {tcdName = name', tcdType = ty', tcdIdInfo = id_infos', tcdLoc = loc})
where
- rn_deriv clas
- = lookupOccRn clas `thenRn` \ clas_name ->
-
- -- 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
-
- Just occs -> mapRn lookupImplicitOccRn occs `thenRn_`
- returnRn clas_name
-\end{code}
+ doc_str = text "In the interface signature for" <+> quotes (ppr name)
-\begin{code}
-rnConDecl :: RdrNameConDecl -> RnMS s RenamedConDecl
+rnTyClDecl (ForeignType {tcdName = name, tcdFoType = fo_type, tcdExtName = ext_name, tcdLoc = loc})
+ = pushSrcLocRn loc $
+ lookupTopBndrRn name `thenRn` \ name' ->
+ returnRn (ForeignType {tcdName = name', tcdFoType = fo_type, tcdExtName = ext_name, tcdLoc = loc})
-rnConDecl (ConDecl name tys src_loc)
+rnTyClDecl (TyData {tcdND = new_or_data, tcdCtxt = context, tcdName = tycon,
+ tcdTyVars = tyvars, tcdCons = condecls, tcdNCons = nconstrs,
+ tcdLoc = src_loc, tcdSysNames = sys_names})
= pushSrcLocRn src_loc $
- lookupRn name `thenRn` \ new_name ->
- mapRn rnBangTy tys `thenRn` \ new_tys ->
- returnRn (ConDecl new_name new_tys src_loc)
+ lookupTopBndrRn tycon `thenRn` \ tycon' ->
+ bindTyVarsRn data_doc tyvars $ \ tyvars' ->
+ rnContext data_doc context `thenRn` \ context' ->
+ checkDupOrQualNames data_doc con_names `thenRn_`
+
+ -- Check that there's at least one condecl,
+ -- or else we're reading an interface file, or -fglasgow-exts
+ (if null condecls then
+ doptRn Opt_GlasgowExts `thenRn` \ glaExts ->
+ getModeRn `thenRn` \ mode ->
+ checkRn (glaExts || isInterfaceMode mode)
+ (emptyConDeclsErr tycon)
+ else returnRn ()
+ ) `thenRn_`
-rnConDecl (ConOpDecl ty1 op ty2 src_loc)
- = pushSrcLocRn src_loc $
- lookupRn op `thenRn` \ new_op ->
- rnBangTy ty1 `thenRn` \ new_ty1 ->
- rnBangTy ty2 `thenRn` \ new_ty2 ->
- returnRn (ConOpDecl new_ty1 new_op new_ty2 src_loc)
+ mapRn rnConDecl condecls `thenRn` \ condecls' ->
+ mapRn lookupSysBinder sys_names `thenRn` \ sys_names' ->
+ returnRn (TyData {tcdND = new_or_data, tcdCtxt = context', tcdName = tycon',
+ tcdTyVars = tyvars', tcdCons = condecls', tcdNCons = nconstrs,
+ tcdDerivs = Nothing, tcdLoc = src_loc, tcdSysNames = sys_names'})
+ where
+ data_doc = text "In the data type declaration for" <+> quotes (ppr tycon)
+ con_names = map conDeclName condecls
-rnConDecl (NewConDecl name ty src_loc)
+rnTyClDecl (TySynonym {tcdName = name, tcdTyVars = tyvars, tcdSynRhs = ty, tcdLoc = src_loc})
= pushSrcLocRn src_loc $
- lookupRn name `thenRn` \ new_name ->
- rnHsType ty `thenRn` \ new_ty ->
- returnRn (NewConDecl new_name new_ty src_loc)
+ lookupTopBndrRn name `thenRn` \ name' ->
+ bindTyVarsRn syn_doc tyvars $ \ tyvars' ->
+ rnHsType syn_doc ty `thenRn` \ ty' ->
+ returnRn (TySynonym {tcdName = name', tcdTyVars = tyvars', tcdSynRhs = ty', tcdLoc = src_loc})
+ where
+ syn_doc = text "In the declaration for type synonym" <+> quotes (ppr name)
-rnConDecl (RecConDecl name fields src_loc)
+rnTyClDecl (ClassDecl {tcdCtxt = context, tcdName = cname,
+ tcdTyVars = tyvars, tcdFDs = fds, tcdSigs = sigs,
+ tcdSysNames = names, tcdLoc = src_loc})
+ -- Used for both source and interface file decls
= pushSrcLocRn src_loc $
- lookupRn name `thenRn` \ new_name ->
- mapRn rnField fields `thenRn` \ new_fields ->
- returnRn (RecConDecl new_name new_fields src_loc)
-rnField (names, ty)
- = mapRn lookupRn names `thenRn` \ new_names ->
- rnBangTy ty `thenRn` \ new_ty ->
- returnRn (new_names, new_ty)
+ lookupTopBndrRn 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!
+ mapRn lookupSysBinder names `thenRn` \ names' ->
+
+ -- Tyvars scope over bindings and context
+ bindTyVars2Rn cls_doc tyvars $ \ clas_tyvar_names tyvars' ->
+
+ -- Check the superclasses
+ rnContext cls_doc context `thenRn` \ context' ->
-rnBangTy (Banged ty)
- = rnHsType ty `thenRn` \ new_ty ->
- returnRn (Banged new_ty)
+ -- Check the functional dependencies
+ rnFds cls_doc fds `thenRn` \ fds' ->
+
+ -- Check the signatures
+ -- First process the class op sigs (op_sigs), then the fixity sigs (non_op_sigs).
+ let
+ (op_sigs, non_op_sigs) = partition isClassOpSig sigs
+ sig_rdr_names_w_locs = [(op,locn) | ClassOpSig op _ _ locn <- sigs]
+ in
+ checkDupOrQualNames sig_doc sig_rdr_names_w_locs `thenRn_`
+ mapRn (rnClassOp cname' clas_tyvar_names fds') op_sigs `thenRn` \ sigs' ->
+ let
+ binders = mkNameSet [ nm | (ClassOpSig nm _ _ _) <- sigs' ]
+ in
+ renameSigs (okClsDclSig binders) non_op_sigs `thenRn` \ non_ops' ->
+
+ -- 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 (ClassDecl { tcdCtxt = context', tcdName = cname', tcdTyVars = tyvars',
+ tcdFDs = fds', tcdSigs = non_ops' ++ sigs', tcdMeths = Nothing,
+ tcdSysNames = names', tcdLoc = src_loc})
+ where
+ cls_doc = text "In the declaration for class" <+> ppr cname
+ sig_doc = text "In the signatures for class" <+> ppr cname
+
+rnClassOp clas clas_tyvars clas_fds sig@(ClassOpSig op dm_stuff ty locn)
+ = pushSrcLocRn locn $
+ lookupTopBndrRn op `thenRn` \ op_name ->
+
+ -- Check the signature
+ rnHsSigType (quotes (ppr op)) ty `thenRn` \ new_ty ->
+
+ -- Make the default-method name
+ (case dm_stuff of
+ DefMeth dm_rdr_name
+ -> -- Imported class that has a default method decl
+ -- See comments with tname, snames, above
+ lookupSysBinder dm_rdr_name `thenRn` \ dm_name ->
+ returnRn (DefMeth dm_name)
+ -- An imported class decl for a class decl that had an explicit default
+ -- method, mentions, rather than defines,
+ -- the default method, so we must arrange to pull it in
+
+ GenDefMeth -> returnRn GenDefMeth
+ NoDefMeth -> returnRn NoDefMeth
+ ) `thenRn` \ dm_stuff' ->
+
+ returnRn (ClassOpSig op_name dm_stuff' new_ty locn)
+
+finishSourceTyClDecl :: RdrNameTyClDecl -> RenamedTyClDecl -> RnMS (RenamedTyClDecl, FreeVars)
+ -- Used for source file decls only
+ -- Renames the default-bindings of a class decl
+ -- the derivings of a data decl
+finishSourceTyClDecl (TyData {tcdDerivs = Just derivs, tcdLoc = src_loc}) -- Derivings in here
+ rn_ty_decl -- Everything else is here
+ = pushSrcLocRn src_loc $
+ mapRn rnDeriv derivs `thenRn` \ derivs' ->
+ returnRn (rn_ty_decl {tcdDerivs = Just derivs'}, mkNameSet derivs')
+
+finishSourceTyClDecl (ClassDecl {tcdMeths = Just mbinds, tcdLoc = src_loc}) -- Get mbinds from here
+ rn_cls_decl@(ClassDecl {tcdName = cls, tcdTyVars = tyvars}) -- Everything else is here
+ -- There are some default-method bindings (abeit possibly empty) so
+ -- this is a source-code class declaration
+ = -- 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.
+ -- Hence the
+ pushSrcLocRn src_loc $
+ extendTyVarEnvFVRn (map hsTyVarName tyvars) $
+ getLocalNameEnv `thenRn` \ name_env ->
+ let
+ meth_rdr_names_w_locs = collectLocatedMonoBinders mbinds
+ gen_rdr_tyvars_w_locs = [(tv,src_loc) | tv <- extractGenericPatTyVars mbinds,
+ not (tv `elemRdrEnv` name_env)]
+ in
+ checkDupOrQualNames meth_doc meth_rdr_names_w_locs `thenRn_`
+ newLocalsRn gen_rdr_tyvars_w_locs `thenRn` \ gen_tyvars ->
+ rnMethodBinds cls gen_tyvars mbinds `thenRn` \ (mbinds', meth_fvs) ->
+ returnRn (rn_cls_decl {tcdMeths = Just mbinds'}, meth_fvs)
+ where
+ meth_doc = text "In the default-methods for class" <+> ppr (tcdName rn_cls_decl)
-rnBangTy (Unbanged ty)
- = rnHsType ty `thenRn` \ new_ty ->
- returnRn (Unbanged new_ty)
+finishSourceTyClDecl _ tycl_decl = returnRn (tycl_decl, emptyFVs)
+ -- Not a class or data type declaration
\end{code}
%*********************************************************
%* *
-\subsection{Support code to rename types}
+\subsection{Support code for type/data declarations}
%* *
%*********************************************************
\begin{code}
-rnHsType :: RdrNameHsType -> RnMS s RenamedHsType
+rnDeriv :: RdrName -> RnMS Name
+rnDeriv cls
+ = lookupOccRn cls `thenRn` \ clas_name ->
+ checkRn (getUnique clas_name `elem` derivableClassKeys)
+ (derivingNonStdClassErr clas_name) `thenRn_`
+ returnRn clas_name
+\end{code}
-rnHsType (HsForAllTy tvs ctxt ty)
- = rn_poly_help tvs ctxt ty
+\begin{code}
+conDeclName :: RdrNameConDecl -> (RdrName, SrcLoc)
+conDeclName (ConDecl n _ _ _ _ l) = (n,l)
+
+rnConDecl :: RdrNameConDecl -> RnMS RenamedConDecl
+rnConDecl (ConDecl name wkr tvs cxt details locn)
+ = pushSrcLocRn locn $
+ checkConName name `thenRn_`
+ lookupTopBndrRn name `thenRn` \ new_name ->
+
+ lookupSysBinder wkr `thenRn` \ new_wkr ->
+ -- See comments with ClassDecl
+
+ bindTyVarsRn doc tvs $ \ new_tyvars ->
+ rnContext doc cxt `thenRn` \ new_context ->
+ rnConDetails doc locn details `thenRn` \ new_details ->
+ returnRn (ConDecl new_name new_wkr new_tyvars new_context new_details locn)
+ where
+ doc = text "In the definition of data constructor" <+> quotes (ppr name)
-rnHsType full_ty@(HsPreForAllTy ctxt ty)
- = getNameEnv `thenRn` \ name_env ->
- let
- mentioned_tyvars = extractHsTyVars full_ty
- forall_tyvars = filter not_in_scope mentioned_tyvars
- not_in_scope tv = case lookupFM name_env tv of
- Nothing -> True
- Just _ -> False
- in
- rn_poly_help (map UserTyVar forall_tyvars) ctxt ty
-
-rnHsType (MonoTyVar tyvar)
- = lookupOccRn tyvar `thenRn` \ tyvar' ->
- returnRn (MonoTyVar tyvar')
-
-rnHsType (MonoFunTy ty1 ty2)
- = andRn MonoFunTy (rnHsType ty1) (rnHsType ty2)
-
-rnHsType (MonoListTy _ ty)
- = lookupImplicitOccRn listType_RDR `thenRn` \ tycon_name ->
- rnHsType ty `thenRn` \ ty' ->
- returnRn (MonoListTy tycon_name ty')
-
-rnHsType (MonoTupleTy _ tys)
- = lookupImplicitOccRn (tupleType_RDR (length tys)) `thenRn` \ tycon_name ->
- mapRn rnHsType tys `thenRn` \ tys' ->
- returnRn (MonoTupleTy tycon_name tys')
-
-rnHsType (MonoTyApp name tys)
- = lookupOccRn name `thenRn` \ name' ->
- mapRn rnHsType tys `thenRn` \ tys' ->
- returnRn (MonoTyApp name' tys')
-
-rnHsType (MonoDictTy clas ty)
- = lookupOccRn clas `thenRn` \ clas' ->
- rnHsType ty `thenRn` \ ty' ->
- returnRn (MonoDictTy clas' ty')
-
-
-rn_poly_help :: [HsTyVar RdrName] -- Universally quantified tyvars
- -> RdrNameContext
- -> RdrNameHsType
- -> RnMS s RenamedHsType
-
-rn_poly_help tyvars ctxt ty
- = bindTyVarsRn "type signature" tyvars $ \ new_tyvars ->
- rnContext ctxt `thenRn` \ new_ctxt ->
- rnHsType ty `thenRn` \ new_ty ->
- returnRn (HsForAllTy new_tyvars new_ctxt new_ty)
+rnConDetails doc locn (VanillaCon tys)
+ = mapRn (rnBangTy doc) tys `thenRn` \ new_tys ->
+ returnRn (VanillaCon new_tys)
+
+rnConDetails doc locn (InfixCon ty1 ty2)
+ = rnBangTy doc ty1 `thenRn` \ new_ty1 ->
+ rnBangTy doc ty2 `thenRn` \ new_ty2 ->
+ returnRn (InfixCon new_ty1 new_ty2)
+
+rnConDetails doc locn (RecCon fields)
+ = checkDupOrQualNames doc field_names `thenRn_`
+ mapRn (rnField doc) fields `thenRn` \ new_fields ->
+ returnRn (RecCon new_fields)
+ where
+ field_names = [(fld, locn) | (flds, _) <- fields, fld <- flds]
+
+rnField doc (names, ty)
+ = mapRn lookupTopBndrRn names `thenRn` \ new_names ->
+ rnBangTy doc ty `thenRn` \ new_ty ->
+ returnRn (new_names, new_ty)
+
+rnBangTy doc (BangType s ty)
+ = rnHsType doc ty `thenRn` \ new_ty ->
+ returnRn (BangType s new_ty)
+
+-- 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
+
+checkConName name
+ = checkRn (isRdrDataCon name)
+ (badDataCon name)
\end{code}
+%*********************************************************
+%* *
+\subsection{Support code to rename types}
+%* *
+%*********************************************************
+
\begin{code}
-rnContext :: RdrNameContext -> RnMS s RenamedContext
+rnFds :: SDoc -> [FunDep RdrName] -> RnMS [FunDep Name]
-rnContext ctxt
- = mapRn rn_ctxt ctxt `thenRn` \ result ->
- let
- (_, dup_asserts) = removeDups cmp_assert result
- in
- -- If this isn't an error, then it ought to be:
- mapRn (addWarnRn . dupClassAssertWarn result) dup_asserts `thenRn_`
- returnRn result
+rnFds doc fds
+ = mapRn rn_fds fds
where
- rn_ctxt (clas, ty)
- = lookupOccRn clas `thenRn` \ clas_name ->
- rnHsType ty `thenRn` \ ty' ->
- returnRn (clas_name, ty')
+ rn_fds (tys1, tys2)
+ = rnHsTyVars doc tys1 `thenRn` \ tys1' ->
+ rnHsTyVars doc tys2 `thenRn` \ tys2' ->
+ returnRn (tys1', tys2')
- cmp_assert (c1,ty1) (c2,ty2)
- = (c1 `cmp` c2) `thenCmp` (cmpHsType cmp ty1 ty2)
+rnHsTyVars doc tvs = mapRn (rnHsTyvar doc) tvs
+rnHsTyvar doc tyvar = lookupOccRn tyvar
\end{code}
-
%*********************************************************
-%* *
+%* *
\subsection{IdInfo}
-%* *
+%* *
%*********************************************************
\begin{code}
-rnIdInfo (HsStrictness strict)
- = rnStrict strict `thenRn` \ strict' ->
- returnRn (HsStrictness strict')
+rnIdInfo (HsWorker worker arity)
+ = lookupOccRn worker `thenRn` \ worker' ->
+ returnRn (HsWorker worker' arity)
-rnIdInfo (HsUnfold expr) = rnCoreExpr expr `thenRn` \ expr' ->
- returnRn (HsUnfold expr')
+rnIdInfo (HsUnfold inline expr) = rnCoreExpr expr `thenRn` \ expr' ->
+ returnRn (HsUnfold inline expr')
+rnIdInfo (HsStrictness str) = returnRn (HsStrictness str)
rnIdInfo (HsArity arity) = returnRn (HsArity arity)
-rnIdInfo (HsUpdate update) = returnRn (HsUpdate update)
-rnIdInfo (HsFBType fb) = returnRn (HsFBType fb)
-rnIdInfo (HsArgUsage au) = returnRn (HsArgUsage au)
-rnIdInfo (HsDeforest df) = returnRn (HsDeforest df)
-
-rnStrict (StrictnessInfo demands (Just worker))
- = lookupOptionalOccRn worker `thenRn` \ worker' ->
- returnRn (StrictnessInfo demands (Just worker'))
-
--- Boring, but necessary for the type checker.
-rnStrict (StrictnessInfo demands Nothing) = returnRn (StrictnessInfo demands Nothing)
-rnStrict BottomGuaranteed = returnRn BottomGuaranteed
-rnStrict NoStrictnessInfo = returnRn NoStrictnessInfo
+rnIdInfo HsNoCafRefs = returnRn HsNoCafRefs
\end{code}
-UfCore expressions.
+@UfCore@ expressions.
\begin{code}
+rnCoreExpr (UfType ty)
+ = rnHsType (text "unfolding type") ty `thenRn` \ ty' ->
+ returnRn (UfType ty')
+
rnCoreExpr (UfVar v)
- = lookupOptionalOccRn v `thenRn` \ v' ->
+ = lookupOccRn v `thenRn` \ v' ->
returnRn (UfVar v')
-rnCoreExpr (UfLit lit) = returnRn (UfLit lit)
+rnCoreExpr (UfLit l)
+ = returnRn (UfLit l)
+
+rnCoreExpr (UfLitLit l ty)
+ = rnHsType (text "litlit") ty `thenRn` \ ty' ->
+ returnRn (UfLitLit l ty')
-rnCoreExpr (UfCon con args)
- = lookupOptionalOccRn con `thenRn` \ con' ->
- mapRn rnCoreArg args `thenRn` \ args' ->
- returnRn (UfCon con' args')
+rnCoreExpr (UfFCall cc ty)
+ = rnHsType (text "ccall") ty `thenRn` \ ty' ->
+ returnRn (UfFCall cc ty')
-rnCoreExpr (UfPrim prim args)
- = rnCorePrim prim `thenRn` \ prim' ->
- mapRn rnCoreArg args `thenRn` \ args' ->
- returnRn (UfPrim prim' args')
+rnCoreExpr (UfTuple (HsTupCon _ boxity arity) args)
+ = mapRn rnCoreExpr args `thenRn` \ args' ->
+ returnRn (UfTuple (HsTupCon tup_name boxity arity) args')
+ where
+ tup_name = getName (dataConId (tupleCon boxity arity))
+ -- Get the *worker* name and use that
rnCoreExpr (UfApp fun arg)
= rnCoreExpr fun `thenRn` \ fun' ->
- rnCoreArg arg `thenRn` \ arg' ->
+ rnCoreExpr arg `thenRn` \ arg' ->
returnRn (UfApp fun' arg')
-rnCoreExpr (UfCase scrut alts)
- = rnCoreExpr scrut `thenRn` \ scrut' ->
- rnCoreAlts alts `thenRn` \ alts' ->
- returnRn (UfCase scrut' alts')
-
-rnCoreExpr (UfSCC cc expr)
- = rnCoreExpr expr `thenRn` \ expr' ->
- returnRn (UfSCC cc expr')
+rnCoreExpr (UfCase scrut bndr alts)
+ = rnCoreExpr scrut `thenRn` \ scrut' ->
+ bindCoreLocalRn bndr $ \ bndr' ->
+ mapRn rnCoreAlt alts `thenRn` \ alts' ->
+ returnRn (UfCase scrut' bndr' alts')
-rnCoreExpr(UfCoerce coercion ty body)
- = rnCoercion coercion `thenRn` \ coercion' ->
- rnHsType ty `thenRn` \ ty' ->
- rnCoreExpr body `thenRn` \ body' ->
- returnRn (UfCoerce coercion' ty' body')
+rnCoreExpr (UfNote note expr)
+ = rnNote note `thenRn` \ note' ->
+ rnCoreExpr expr `thenRn` \ expr' ->
+ returnRn (UfNote note' expr')
rnCoreExpr (UfLam bndr body)
= rnCoreBndr bndr $ \ bndr' ->
\begin{code}
rnCoreBndr (UfValBinder name ty) thing_inside
- = rnHsType ty `thenRn` \ ty' ->
- bindLocalsRn "unfolding value" [name] $ \ [name'] ->
+ = rnHsType doc ty `thenRn` \ ty' ->
+ bindCoreLocalRn name $ \ name' ->
thing_inside (UfValBinder name' ty')
+ where
+ doc = text "unfolding id"
rnCoreBndr (UfTyBinder name kind) thing_inside
- = bindLocalsRn "unfolding tyvar" [name] $ \ [name'] ->
+ = bindCoreLocalRn name $ \ name' ->
thing_inside (UfTyBinder name' kind)
-rnCoreBndr (UfUsageBinder name) thing_inside
- = bindLocalsRn "unfolding usage" [name] $ \ [name'] ->
- thing_inside (UfUsageBinder name')
-
-rnCoreBndrs bndrs thing_inside -- Expect them all to be ValBinders
- = mapRn rnHsType tys `thenRn` \ tys' ->
- bindLocalsRn "unfolding value" names $ \ names' ->
- thing_inside (zipWith UfValBinder names' tys')
- where
- names = map (\ (UfValBinder name _) -> name) bndrs
- tys = map (\ (UfValBinder _ ty) -> ty) bndrs
+rnCoreBndrs [] thing_inside = thing_inside []
+rnCoreBndrs (b:bs) thing_inside = rnCoreBndr b $ \ name' ->
+ rnCoreBndrs bs $ \ names' ->
+ thing_inside (name':names')
\end{code}
\begin{code}
-rnCoreArg (UfVarArg v) = lookupOptionalOccRn v `thenRn` \ v' -> returnRn (UfVarArg v')
-rnCoreArg (UfUsageArg u) = lookupOptionalOccRn u `thenRn` \ u' -> returnRn (UfUsageArg u')
-rnCoreArg (UfTyArg ty) = rnHsType ty `thenRn` \ ty' -> returnRn (UfTyArg ty')
-rnCoreArg (UfLitArg lit) = returnRn (UfLitArg lit)
-
-rnCoreAlts (UfAlgAlts alts deflt)
- = mapRn rn_alt alts `thenRn` \ alts' ->
- rnCoreDefault deflt `thenRn` \ deflt' ->
- returnRn (UfAlgAlts alts' deflt')
- where
- rn_alt (con, bndrs, rhs) = lookupOptionalOccRn con `thenRn` \ con' ->
- rnCoreBndrs bndrs $ \ bndrs' ->
- rnCoreExpr rhs `thenRn` \ rhs' ->
- returnRn (con', bndrs', rhs')
-
-rnCoreAlts (UfPrimAlts alts deflt)
- = mapRn rn_alt alts `thenRn` \ alts' ->
- rnCoreDefault deflt `thenRn` \ deflt' ->
- returnRn (UfPrimAlts alts' deflt')
- where
- rn_alt (lit, rhs) = rnCoreExpr rhs `thenRn` \ rhs' ->
- returnRn (lit, rhs')
+rnCoreAlt (con, bndrs, rhs)
+ = rnUfCon con `thenRn` \ con' ->
+ bindCoreLocalsRn bndrs $ \ bndrs' ->
+ rnCoreExpr rhs `thenRn` \ rhs' ->
+ returnRn (con', bndrs', rhs')
-rnCoreDefault UfNoDefault = returnRn UfNoDefault
-rnCoreDefault (UfBindDefault bndr rhs) = rnCoreBndr bndr $ \ bndr' ->
- rnCoreExpr rhs `thenRn` \ rhs' ->
- returnRn (UfBindDefault bndr' rhs')
+rnNote (UfCoerce ty)
+ = rnHsType (text "unfolding coerce") ty `thenRn` \ ty' ->
+ returnRn (UfCoerce ty')
-rnCoercion (UfIn n) = lookupOptionalOccRn n `thenRn` \ n' -> returnRn (UfIn n')
-rnCoercion (UfOut n) = lookupOptionalOccRn n `thenRn` \ n' -> returnRn (UfOut n')
+rnNote (UfSCC cc) = returnRn (UfSCC cc)
+rnNote UfInlineCall = returnRn UfInlineCall
+rnNote UfInlineMe = returnRn UfInlineMe
-rnCorePrim (UfOtherOp op)
- = lookupOptionalOccRn op `thenRn` \ op' ->
- returnRn (UfOtherOp op')
-rnCorePrim (UfCCallOp str casm gc arg_tys res_ty)
- = mapRn rnHsType arg_tys `thenRn` \ arg_tys' ->
- rnHsType res_ty `thenRn` \ res_ty' ->
- returnRn (UfCCallOp str casm gc arg_tys' res_ty')
-\end{code}
+rnUfCon UfDefault
+ = returnRn UfDefault
-%*********************************************************
-%* *
-\subsection{Errors}
-%* *
-%*********************************************************
-
-\begin{code}
-derivingNonStdClassErr clas sty
- = ppCat [ppStr "non-standard class in deriving:", ppr sty clas]
+rnUfCon (UfTupleAlt (HsTupCon _ boxity arity))
+ = returnRn (UfTupleAlt (HsTupCon tup_name boxity arity))
+ where
+ tup_name = getName (tupleCon boxity arity)
-classTyVarNotInOpTyErr clas_tyvar sig sty
- = ppHang (ppBesides [ppStr "Class type variable `", ppr sty clas_tyvar, ppStr "' does not appear in method signature:"])
- 4 (ppr sty sig)
+rnUfCon (UfDataAlt con)
+ = lookupOccRn con `thenRn` \ con' ->
+ returnRn (UfDataAlt con')
-classTyVarInOpCtxtErr clas_tyvar sig sty
- = ppHang (ppBesides [ ppStr "Class type variable `", ppr sty clas_tyvar,
- ppStr "' present in method's local overloading context:"])
- 4 (ppr sty sig)
+rnUfCon (UfLitAlt lit)
+ = returnRn (UfLitAlt lit)
-dupClassAssertWarn ctxt dups sty
- = ppHang (ppBesides [ppStr "Duplicate class assertion `", ppr sty dups, ppStr "' in context:"])
- 4 (ppr sty ctxt)
+rnUfCon (UfLitLitAlt lit ty)
+ = rnHsType (text "litlit") ty `thenRn` \ ty' ->
+ returnRn (UfLitLitAlt lit ty')
\end{code}
-
-
-
-
-=================== OLD STUFF ======================
-
%*********************************************************
%* *
-\subsection{SPECIALIZE data pragmas}
+\subsection{Rule shapes}
%* *
%*********************************************************
-\begin{pseudocode}
-rnSpecDataSig :: RdrNameSpecDataSig
- -> RnMS s RenamedSpecDataSig
+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.
-rnSpecDataSig (SpecDataSig tycon ty src_loc)
- = pushSrcLocRn src_loc $
- let
- tyvars = filter extractHsTyNames ty
- in
- mkTyVarNamesEnv src_loc tyvars `thenRn` \ (tv_env,_) ->
- lookupOccRn tycon `thenRn` \ tycon' ->
- rnHsType tv_env ty `thenRn` \ ty' ->
- returnRn (SpecDataSig tycon' ty' src_loc)
+\begin{code}
+validRuleLhs foralls lhs
+ = check lhs
+ where
+ check (OpApp _ op _ _) = check op
+ check (HsApp e1 e2) = check e1
+ check (HsVar v) | v `notElem` foralls = True
+ check other = False
+\end{code}
-\end{pseudocode}
%*********************************************************
-%* *
-\subsection{@SPECIALIZE instance@ user-pragmas}
-%* *
+%* *
+\subsection{Errors}
+%* *
%*********************************************************
-\begin{pseudocode}
-rnSpecInstSig :: RdrNameSpecInstSig
- -> RnMS s RenamedSpecInstSig
-
-rnSpecInstSig (SpecInstSig clas ty src_loc)
- = pushSrcLocRn src_loc $
- let
- tyvars = extractHsTyNames is_tyvar_name ty
- in
- mkTyVarNamesEnv src_loc tyvars `thenRn` \ (tv_env,_) ->
- lookupOccRn clas `thenRn` \ new_clas ->
- rnHsType tv_env ty `thenRn` \ new_ty ->
- returnRn (SpecInstSig new_clas new_ty src_loc)
-\end{pseudocode}
+\begin{code}
+derivingNonStdClassErr clas
+ = hsep [ptext SLIT("non-standard class"), ppr clas, ptext SLIT("in deriving clause")]
+
+badDataCon name
+ = hsep [ptext SLIT("Illegal data constructor name"), quotes (ppr name)]
+badRuleLhsErr name lhs
+ = sep [ptext SLIT("Rule") <+> ptext name <> colon,
+ nest 4 (ptext SLIT("Illegal left-hand side:") <+> ppr lhs)]
+ $$
+ ptext SLIT("LHS must be of form (f e1 .. en) where f is not forall'd")
+
+badRuleVar name var
+ = sep [ptext SLIT("Rule") <+> doubleQuotes (ptext name) <> colon,
+ ptext SLIT("Forall'd variable") <+> quotes (ppr var) <+>
+ ptext SLIT("does not appear on left hand side")]
+
+emptyConDeclsErr tycon
+ = sep [quotes (ppr tycon) <+> ptext SLIT("has no constructors"),
+ nest 4 (ptext SLIT("(-fglasgow-exts permits this)"))]
+\end{code}