X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcGenDeriv.lhs;h=d13cb83023869acf8112651740e0994f616769f9;hb=438596897ebbe25a07e1c82085cfbc5bdb00f09e;hp=63641d88fcbe352d7b410f608f8a3b402cafcbdd;hpb=10521d8418fd3a1cf32882718b5bd28992db36fd;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcGenDeriv.lhs b/ghc/compiler/typecheck/TcGenDeriv.lhs index 63641d8..d13cb83 100644 --- a/ghc/compiler/typecheck/TcGenDeriv.lhs +++ b/ghc/compiler/typecheck/TcGenDeriv.lhs @@ -1,5 +1,5 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1995 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TcGenDeriv]{Generating derived instance declarations} @@ -9,99 +9,65 @@ This module is nominally ``subordinate'' to @TcDeriv@, which is the This is where we do all the grimy bindings' generation. \begin{code} -#include "HsVersions.h" - module TcGenDeriv ( - a_Expr, - a_PN, - a_Pat, - ah_PN, - b_Expr, - b_PN, - b_Pat, - bh_PN, - c_Expr, - c_PN, - c_Pat, - ch_PN, - cmp_eq_PN, - d_Expr, - d_PN, - d_Pat, - dh_PN, - eqH_PN, - eq_TAG_Expr, - eq_TAG_PN, - error_PN, - false_Expr, - false_PN, - geH_PN, - gen_Binary_binds, + gen_Bounded_binds, gen_Enum_binds, gen_Eq_binds, gen_Ix_binds, gen_Ord_binds, - gen_Text_binds, + gen_Read_binds, + gen_Show_binds, gen_tag_n_con_monobind, - gt_TAG_Expr, - gt_TAG_PN, - leH_PN, - ltH_PN, - lt_TAG_Expr, - lt_TAG_PN, - minusH_PN, - mkInt_PN, - rangeSize_PN, - true_Expr, - true_PN - ) where -IMPORT_Trace -- ToDo:rm debugging -import Outputable -import Pretty + con2tag_RDR, tag2con_RDR, maxtag_RDR, + + TagThingWanted(..) + ) where -import AbsSyn -- the stuff being typechecked +#include "HsVersions.h" -import AbsPrel {-( trueDataCon, falseDataCon, intDataCon, eRROR_ID, - ltPrimDataCon, eqPrimDataCon, gtPrimDataCon, - charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, - floatPrimTy, doublePrimTy - )-} -import PrimOps -- *********** ditto - -import AbsUniType ( getTyConDataCons, isEnumerationTyCon, - maybeSingleConstructorTyCon, --UNUSED: preludeClassDerivedFor, - -- UNUSED: isEnumerationTyConMostly, - isPrimType, UniType, - TauType(..), TyVarTemplate, ThetaType(..) - IF_ATTACK_PRAGMAS(COMMA cmpUniType) +import HsSyn ( InPat(..), HsExpr(..), MonoBinds(..), + Match(..), GRHSsAndBinds(..), Stmt(..), HsLit(..), + HsBinds(..), StmtCtxt(..), + unguardedRHS ) -import Id ( getDataConArity, getDataConTag, - getDataConSig, isNullaryDataCon, fIRST_TAG, - isDataCon, DataCon(..), ConTag(..), Id +import RdrHsSyn ( RdrName(..), varUnqual, mkOpApp, + RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat ) -import Maybes ( maybeToBool, Maybe(..) ) -import Name ( Name(..) ) -import ProtoName ( ProtoName(..) ) -import RenameAuxFuns -- why not? take all of it... -import RenameMonad4 -- initRn4, etc. -import SrcLoc ( mkGeneratedSrcLoc ) -import TcDeriv ( con2tag_PN, tag2con_PN, maxtag_PN, - TagThingWanted(..), DerivEqn(..) +import BasicTypes ( IfaceFlavour(..), RecFlag(..) ) +import FieldLabel ( fieldLabelName ) +import DataCon ( isNullaryDataCon, dataConTag, + dataConRawArgTys, fIRST_TAG, + DataCon, ConTag, + dataConFieldLabels ) +import Name ( getOccString, getOccName, getSrcLoc, occNameString, + modAndOcc, OccName, Name ) + +import PrimOp ( PrimOp(..) ) +import PrelInfo -- Lots of RdrNames +import SrcLoc ( mkGeneratedSrcLoc, SrcLoc ) +import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, + maybeTyConSingleCon ) -import Unique -- some ClassKey stuff -import Util +import Type ( isUnLiftedType, isUnboxedType, Type ) +import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, + floatPrimTy, doublePrimTy + ) +import Util ( mapAccumL, zipEqual, zipWithEqual, + zipWith3Equal, nOfThem, panic, assertPanic ) +import Maybes ( maybeToBool ) +import List ( partition, intersperse ) \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-classes]{Generating code, by derivable class} +\subsection{Generating code, by derivable class} %* * %************************************************************************ %************************************************************************ %* * -\subsubsection[TcGenDeriv-Eq]{Generating @Eq@ instance declarations} +\subsubsection{Generating @Eq@ instance declarations} %* * %************************************************************************ @@ -164,83 +130,90 @@ case (a1 `eqFloat#` a2) of tycon, we generate: \begin{verbatim} instance ... Eq (Foo ...) where - (==) a b = case (tagCmp a b) of { _LT -> False; _EQ -> True ; _GT -> False} - (/=) a b = case (tagCmp a b) of { _LT -> True ; _EQ -> False; _GT -> True } + (==) a b = case (compare a b) of { _LT -> False; _EQ -> True ; _GT -> False} + (/=) a b = case (compare a b) of { _LT -> True ; _EQ -> False; _GT -> True } \begin{verbatim} However, that requires that \tr{Ord } was put in the context for the instance decl, which it probably wasn't, so the decls produced don't get through the typechecker. \end{itemize} + +deriveEq :: RdrName -- Class + -> RdrName -- Type constructor + -> [ (RdrName, [RdrType]) ] -- Constructors + -> (RdrContext, -- Context for the inst decl + [RdrBind], -- Binds in the inst decl + [RdrBind]) -- Extra value bindings outside + +deriveEq clas tycon constrs + = (context, [eq_bind, ne_bind], []) + where + context = [(clas, [ty]) | (_, tys) <- constrs, ty <- tys] + + ne_bind = mkBind + (nullary_cons, non_nullary_cons) = partition is_nullary constrs + is_nullary (_, args) = null args + \begin{code} -gen_Eq_binds :: TyCon -> ProtoNameMonoBinds +gen_Eq_binds :: TyCon -> RdrNameMonoBinds gen_Eq_binds tycon - = case (partition isNullaryDataCon (getTyConDataCons tycon)) - of { (nullary_cons, nonnullary_cons) -> - let + = let + tycon_loc = getSrcLoc tycon + (nullary_cons, nonnullary_cons) + | isNewTyCon tycon = ([], tyConDataCons tycon) + | otherwise = partition isNullaryDataCon (tyConDataCons tycon) + rest - = if null nullary_cons then - case maybeSingleConstructorTyCon tycon of + = if (null nullary_cons) then + case maybeTyConSingleCon tycon of Just _ -> [] Nothing -> -- if cons don't match, then False [([a_Pat, b_Pat], false_Expr)] else -- calc. and compare the tags - [([a_Pat, b_Pat], - untag_Expr tycon [(a_PN,ah_PN), (b_PN,bh_PN)] - (cmp_tags_Expr eqH_PN ah_PN bh_PN true_Expr false_Expr))] + [([a_Pat, b_Pat], + untag_Expr tycon [(a_RDR,ah_RDR), (b_RDR,bh_RDR)] + (cmp_tags_Expr eqH_Int_RDR ah_RDR bh_RDR true_Expr false_Expr))] in - mk_FunMonoBind eq_PN ((map pats_etc nonnullary_cons) ++ rest) - `AndMonoBinds` boring_ne_method - } - where + mk_FunMonoBind tycon_loc eq_RDR ((map pats_etc nonnullary_cons) ++ rest) + `AndMonoBinds` + mk_easy_FunMonoBind tycon_loc ne_RDR [a_Pat, b_Pat] [] ( + HsApp (HsVar not_RDR) (HsPar (mk_easy_App eq_RDR [a_RDR, b_RDR]))) + where ------------------------------------------------------------------ pats_etc data_con = let - con1_pat = ConPatIn data_con_PN (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) - - data_con_PN = Prel (WiredInVal data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - tys_needed = case (getDataConSig data_con) of - (_,_, arg_tys, _) -> arg_tys - in + con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed) + con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed) + + data_con_RDR = qual_orig_name data_con + con_arity = length tys_needed + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + tys_needed = dataConRawArgTys data_con + in ([con1_pat, con2_pat], nested_eq_expr tys_needed as_needed bs_needed) where - nested_eq_expr [] [] [] = true_Expr - nested_eq_expr [ty] [a] [b] = eq_Expr ty (Var a) (Var b) - nested_eq_expr (t:ts) (a:as) (b:bs) - = let - rest_expr = nested_eq_expr ts as bs - in - and_Expr (eq_Expr t (Var a) (Var b)) rest_expr - -boring_ne_method - = mk_easy_FunMonoBind ne_PN [a_Pat, b_Pat] [] ( - App (Var not_PN) (App (App (Var eq_PN) a_Expr) b_Expr) - ) + nested_eq_expr [] [] [] = true_Expr + nested_eq_expr tys as bs + = foldl1 and_Expr (zipWith3Equal "nested_eq" nested_eq tys as bs) + where + nested_eq ty a b = HsPar (eq_Expr ty (HsVar a) (HsVar b)) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Ord]{Generating @Ord@ instance declarations} +\subsubsection{Generating @Ord@ instance declarations} %* * %************************************************************************ -For a derived @Ord@, we concentrate our attentions on the non-standard -@_tagCmp@ method, which type: +For a derived @Ord@, we concentrate our attentions on @compare@ \begin{verbatim} -_tagCmp :: a -> a -> _CMP_TAG - --- and the builtin tag type is: - -data _CMP_TAG = _LT | _EQ | _GT deriving () +compare :: a -> a -> Ordering +data Ordering = LT | EQ | GT deriving () \end{verbatim} -(All this @_tagCmp@ stuff is due to the sterling analysis by Julian -Seward.) - We will use the same example data type as above: \begin{verbatim} data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ... @@ -248,33 +221,33 @@ data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ... \begin{itemize} \item - We do all the other @Ord@ methods with calls to @_tagCmp@: + We do all the other @Ord@ methods with calls to @compare@: \begin{verbatim} instance ... (Ord ) where - a < b = case _tagCmp a b of { _LT -> True; _EQ -> False; _GT -> False } - a <= b = case _tagCmp a b of { _LT -> True; _EQ -> True; _GT -> False } - a >= b = case _tagCmp a b of { _LT -> False; _EQ -> True; _GT -> True } - a > b = case _tagCmp a b of { _LT -> False; _EQ -> False; _GT -> True } + a < b = case (compare a b) of { LT -> True; EQ -> False; GT -> False } + a <= b = case (compare a b) of { LT -> True; EQ -> True; GT -> False } + a >= b = case (compare a b) of { LT -> False; EQ -> True; GT -> True } + a > b = case (compare a b) of { LT -> False; EQ -> False; GT -> True } - max a b = case _tagCmp a b of { _LT -> b; _EQ -> a; _GT -> a } - min a b = case _tagCmp a b of { _LT -> a; _EQ -> a; _GT -> b } + max a b = case (compare a b) of { LT -> b; EQ -> a; GT -> a } + min a b = case (compare a b) of { LT -> a; EQ -> b; GT -> b } - -- _tagCmp to come... + -- compare to come... \end{verbatim} \item - @_tagCmp@ always has two parts. First, we use the compared + @compare@ always has two parts. First, we use the compared data-constructors' tags to deal with the case of different constructors: \begin{verbatim} -_tagCmp a b = case (con2tag_Foo a) of { a# -> - case (con2tag_Foo b) of { b# -> - case (a# ==# b#) of { +compare a b = case (con2tag_Foo a) of { a# -> + case (con2tag_Foo b) of { b# -> + case (a# ==# b#) of { True -> cmp_eq a b False -> case (a# <# b#) of True -> _LT False -> _GT - }}} + }}} where cmp_eq = ... to come ... \end{verbatim} @@ -284,32 +257,33 @@ _tagCmp a b = case (con2tag_Foo a) of { a# -> comparing data constructors with the same tag. For the ordinary constructors (if any), we emit the sorta-obvious - tagCmp-style stuff; for our example: + compare-style stuff; for our example: \begin{verbatim} cmp_eq (O1 a1 b1) (O1 a2 b2) - = case (_tagCmp a1 a2) of { _LT -> _LT; _EQ -> _tagCmp b1 b2; _GT -> _GT } + = case (compare a1 a2) of { LT -> LT; EQ -> compare b1 b2; GT -> GT } cmp_eq (O2 a1) (O2 a2) - = _tagCmp a1 a2 + = compare a1 a2 cmp_eq (O3 a1 b1 c1) (O3 a2 b2 c2) - = case (_tagCmp a1 a2) of { - _LT -> _LT; - _GT -> _GT; - _EQ -> case _tagCmp b1 b2 of { - _LT -> _LT; - _GT -> _GT; - _EQ -> _tagCmp c1 c2 - } + = case (compare a1 a2) of { + LT -> LT; + GT -> GT; + EQ -> case compare b1 b2 of { + LT -> LT; + GT -> GT; + EQ -> compare c1 c2 + } } \end{verbatim} Again, we must be careful about unboxed comparisons. For example, if \tr{a1} and \tr{a2} were \tr{Int#}s in the 2nd example above, we'd need to generate: + \begin{verbatim} cmp_eq lt eq gt (O2 a1) (O2 a2) - = tagCmpInt# a1 a2 + = compareInt# a1 a2 -- or maybe the unfolded equivalent \end{verbatim} @@ -317,89 +291,112 @@ cmp_eq lt eq gt (O2 a1) (O2 a2) For the remaining nullary constructors, we already know that the tags are equal so: \begin{verbatim} -cmp_eq _ _ = _EQ +cmp_eq _ _ = EQ \end{verbatim} \end{itemize} +If there is only one constructor in the Data Type we don't need the WildCard Pattern. +JJQC-30-Nov-1997 + \begin{code} -gen_Ord_binds :: TyCon -> ProtoNameMonoBinds +gen_Ord_binds :: TyCon -> RdrNameMonoBinds gen_Ord_binds tycon - = defaulted `AndMonoBinds` tagCmp + = defaulted `AndMonoBinds` compare where + tycon_loc = getSrcLoc tycon -------------------------------------------------------------------- - tagCmp = mk_easy_FunMonoBind tagCmp_PN + compare = mk_easy_FunMonoBind tycon_loc compare_RDR [a_Pat, b_Pat] [cmp_eq] - (if maybeToBool (maybeSingleConstructorTyCon tycon) then - cmp_eq_Expr lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr a_Expr b_Expr + (if maybeToBool (maybeTyConSingleCon tycon) then + cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr else - untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] - (cmp_tags_Expr eqH_PN ah_PN bh_PN + untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] + (cmp_tags_Expr eqH_Int_RDR ah_RDR bh_RDR -- True case; they are equal -- If an enumeration type we are done; else -- recursively compare their components (if isEnumerationTyCon tycon then - eq_TAG_Expr + eqTag_Expr else - cmp_eq_Expr lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr a_Expr b_Expr + cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr ) -- False case; they aren't equal -- So we need to do a less-than comparison on the tags - (cmp_tags_Expr ltH_PN ah_PN bh_PN lt_TAG_Expr gt_TAG_Expr))) + (cmp_tags_Expr ltH_Int_RDR ah_RDR bh_RDR ltTag_Expr gtTag_Expr))) + tycon_data_cons = tyConDataCons tycon (nullary_cons, nonnullary_cons) - = partition isNullaryDataCon (getTyConDataCons tycon) - - cmp_eq - = mk_FunMonoBind cmp_eq_PN (map pats_etc nonnullary_cons ++ deflt_pats_etc) + | isNewTyCon tycon = ([], tyConDataCons tycon) + | otherwise = partition isNullaryDataCon tycon_data_cons + + cmp_eq = + mk_FunMonoBind tycon_loc + cmp_eq_RDR + (if null nonnullary_cons && (length nullary_cons == 1) then + -- catch this specially to avoid warnings + -- about overlapping patterns from the desugarer. + let + data_con = head nullary_cons + data_con_RDR = qual_orig_name data_con + pat = ConPatIn data_con_RDR [] + in + [([pat,pat], eqTag_Expr)] + else + map pats_etc nonnullary_cons ++ + -- leave out wildcards to silence desugarer. + (if length tycon_data_cons == 1 then + [] + else + [([WildPatIn, WildPatIn], default_rhs)])) where pats_etc data_con = ([con1_pat, con2_pat], - nested_tagCmp_expr tys_needed as_needed bs_needed) + nested_compare_expr tys_needed as_needed bs_needed) where - con1_pat = ConPatIn data_con_PN (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) - - data_con_PN = Prel (WiredInVal data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - tys_needed = case (getDataConSig data_con) of - (_,_, arg_tys, _) -> arg_tys - - nested_tagCmp_expr [ty] [a] [b] - = careful_tagCmp_Case ty lt_TAG_Expr eq_TAG_Expr gt_TAG_Expr (Var a) (Var b) - - nested_tagCmp_expr (ty:tys) (a:as) (b:bs) - = let eq_expr = nested_tagCmp_expr tys as bs - in careful_tagCmp_Case ty lt_TAG_Expr eq_expr gt_TAG_Expr (Var a) (Var b) - - deflt_pats_etc - = if null nullary_cons - then [] - else [([a_Pat, b_Pat], eq_TAG_Expr)] + con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed) + con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed) + + data_con_RDR = qual_orig_name data_con + con_arity = length tys_needed + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + tys_needed = dataConRawArgTys data_con + + nested_compare_expr [ty] [a] [b] + = careful_compare_Case ty ltTag_Expr eqTag_Expr gtTag_Expr (HsVar a) (HsVar b) + + nested_compare_expr (ty:tys) (a:as) (b:bs) + = let eq_expr = nested_compare_expr tys as bs + in careful_compare_Case ty ltTag_Expr eq_expr gtTag_Expr (HsVar a) (HsVar b) + + default_rhs | null nullary_cons = impossible_Expr -- Keep desugarer from complaining about + -- inexhaustive patterns + | otherwise = eqTag_Expr -- Some nullary constructors; + -- Tags are equal, no args => return EQ -------------------------------------------------------------------- defaulted = foldr1 AndMonoBinds [lt, le, ge, gt, max_, min_] -lt = mk_easy_FunMonoBind lt_PN [a_Pat, b_Pat] [] ( - tagCmp_Case true_Expr false_Expr false_Expr a_Expr b_Expr) -le = mk_easy_FunMonoBind le_PN [a_Pat, b_Pat] [] ( - tagCmp_Case true_Expr true_Expr false_Expr a_Expr b_Expr) -ge = mk_easy_FunMonoBind ge_PN [a_Pat, b_Pat] [] ( - tagCmp_Case false_Expr true_Expr true_Expr a_Expr b_Expr) -gt = mk_easy_FunMonoBind gt_PN [a_Pat, b_Pat] [] ( - tagCmp_Case false_Expr false_Expr true_Expr a_Expr b_Expr) - -max_ = mk_easy_FunMonoBind max_PN [a_Pat, b_Pat] [] ( - tagCmp_Case b_Expr a_Expr a_Expr a_Expr b_Expr) -min_ = mk_easy_FunMonoBind min_PN [a_Pat, b_Pat] [] ( - tagCmp_Case a_Expr a_Expr b_Expr a_Expr b_Expr) +lt = mk_easy_FunMonoBind mkGeneratedSrcLoc lt_RDR [a_Pat, b_Pat] [] ( + compare_Case true_Expr false_Expr false_Expr a_Expr b_Expr) +le = mk_easy_FunMonoBind mkGeneratedSrcLoc le_RDR [a_Pat, b_Pat] [] ( + compare_Case true_Expr true_Expr false_Expr a_Expr b_Expr) +ge = mk_easy_FunMonoBind mkGeneratedSrcLoc ge_RDR [a_Pat, b_Pat] [] ( + compare_Case false_Expr true_Expr true_Expr a_Expr b_Expr) +gt = mk_easy_FunMonoBind mkGeneratedSrcLoc gt_RDR [a_Pat, b_Pat] [] ( + compare_Case false_Expr false_Expr true_Expr a_Expr b_Expr) + +max_ = mk_easy_FunMonoBind mkGeneratedSrcLoc max_RDR [a_Pat, b_Pat] [] ( + compare_Case b_Expr a_Expr a_Expr a_Expr b_Expr) +min_ = mk_easy_FunMonoBind mkGeneratedSrcLoc min_RDR [a_Pat, b_Pat] [] ( + compare_Case a_Expr b_Expr b_Expr a_Expr b_Expr) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Enum]{Generating @Enum@ instance declarations} +\subsubsection{Generating @Enum@ instance declarations} %* * %************************************************************************ @@ -413,6 +410,8 @@ we use both @con2tag_Foo@ and @tag2con_Foo@ functions, as well as a \begin{verbatim} instance ... Enum (Foo ...) where + toEnum i = tag2con_Foo i + enumFrom a = map tag2con_Foo [con2tag_Foo a .. maxtag_Foo] -- or, really... @@ -434,32 +433,81 @@ instance ... Enum (Foo ...) where For @enumFromTo@ and @enumFromThenTo@, we use the default methods. \begin{code} -gen_Enum_binds :: TyCon -> ProtoNameMonoBinds +gen_Enum_binds :: TyCon -> RdrNameMonoBinds gen_Enum_binds tycon - = enum_from `AndMonoBinds` enum_from_then + = to_enum `AndMonoBinds` + enum_from `AndMonoBinds` + enum_from_then `AndMonoBinds` + from_enum where + tycon_loc = getSrcLoc tycon + + to_enum + = mk_easy_FunMonoBind tycon_loc toEnum_RDR [a_Pat] [] $ + mk_easy_App (tag2con_RDR tycon) [a_RDR] + enum_from - = mk_easy_FunMonoBind enumFrom_PN [a_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - App (App (Var map_PN) (Var (tag2con_PN tycon))) ( - enum_from_to_Expr - (App (Var mkInt_PN) (Var ah_PN)) - (Var (maxtag_PN tycon))))) + = mk_easy_FunMonoBind tycon_loc enumFrom_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + HsApp (mk_easy_App map_RDR [tag2con_RDR tycon]) $ + HsPar (enum_from_to_Expr + (mk_easy_App mkInt_RDR [ah_RDR]) + (HsVar (maxtag_RDR tycon))) enum_from_then - = mk_easy_FunMonoBind enumFromThen_PN [a_Pat, b_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN), (b_PN, bh_PN)] ( - App (App (Var map_PN) (Var (tag2con_PN tycon))) ( - enum_from_then_to_Expr - (App (Var mkInt_PN) (Var ah_PN)) - (App (Var mkInt_PN) (Var bh_PN)) - (Var (maxtag_PN tycon))))) + = mk_easy_FunMonoBind tycon_loc enumFromThen_RDR [a_Pat, b_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] $ + HsApp (mk_easy_App map_RDR [tag2con_RDR tycon]) $ + HsPar (enum_from_then_to_Expr + (mk_easy_App mkInt_RDR [ah_RDR]) + (mk_easy_App mkInt_RDR [bh_RDR]) + (HsVar (maxtag_RDR tycon))) + + from_enum + = mk_easy_FunMonoBind tycon_loc fromEnum_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + (mk_easy_App mkInt_RDR [ah_RDR]) +\end{code} + +%************************************************************************ +%* * +\subsubsection{Generating @Bounded@ instance declarations} +%* * +%************************************************************************ + +\begin{code} +gen_Bounded_binds tycon + = if isEnumerationTyCon tycon then + min_bound_enum `AndMonoBinds` max_bound_enum + else + ASSERT(length data_cons == 1) + min_bound_1con `AndMonoBinds` max_bound_1con + where + data_cons = tyConDataCons tycon + tycon_loc = getSrcLoc tycon + + ----- enum-flavored: --------------------------- + min_bound_enum = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] (HsVar data_con_1_RDR) + max_bound_enum = mk_easy_FunMonoBind tycon_loc maxBound_RDR [] [] (HsVar data_con_N_RDR) + + data_con_1 = head data_cons + data_con_N = last data_cons + data_con_1_RDR = qual_orig_name data_con_1 + data_con_N_RDR = qual_orig_name data_con_N + + ----- single-constructor-flavored: ------------- + arity = argFieldCount data_con_1 + + min_bound_1con = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] $ + mk_easy_App data_con_1_RDR (nOfThem arity minBound_RDR) + max_bound_1con = mk_easy_FunMonoBind tycon_loc maxBound_RDR [] [] $ + mk_easy_App data_con_1_RDR (nOfThem arity maxBound_RDR) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Ix]{Generating @Ix@ instance declarations} +\subsubsection{Generating @Ix@ instance declarations} %* * %************************************************************************ @@ -479,7 +527,7 @@ instance ... Ix (Foo ...) where -- or, really... range (a, b) = case (con2tag_Foo a) of { a# -> - case (con2tag_Foo b) of { b# -> + case (con2tag_Foo b) of { b# -> map tag2con_Foo (enumFromTo (I# a#) (I# b#)) }} @@ -516,246 +564,346 @@ we follow the scheme given in Figure~19 of the Haskell~1.2 report (p.~147). \begin{code} -gen_Ix_binds :: TyCon -> ProtoNameMonoBinds +gen_Ix_binds :: TyCon -> RdrNameMonoBinds gen_Ix_binds tycon = if isEnumerationTyCon tycon then enum_ixes else single_con_ixes where - tycon_str = _UNPK_ (snd (getOrigName tycon)) + tycon_str = getOccString tycon + tycon_loc = getSrcLoc tycon -------------------------------------------------------------- enum_ixes = enum_range `AndMonoBinds` enum_index `AndMonoBinds` enum_inRange enum_range - = mk_easy_FunMonoBind range_PN [TuplePatIn [a_Pat, b_Pat]] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(b_PN, bh_PN)] ( - App (App (Var map_PN) (Var (tag2con_PN tycon))) ( - enum_from_to_Expr - (App (Var mkInt_PN) (Var ah_PN)) - (App (Var mkInt_PN) (Var bh_PN)) - )))) + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePatIn [a_Pat, b_Pat] True{-boxed-}] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + untag_Expr tycon [(b_RDR, bh_RDR)] $ + HsApp (mk_easy_App map_RDR [tag2con_RDR tycon]) $ + HsPar (enum_from_to_Expr + (mk_easy_App mkInt_RDR [ah_RDR]) + (mk_easy_App mkInt_RDR [bh_RDR])) enum_index - = mk_easy_FunMonoBind index_PN [AsPatIn c_PN (TuplePatIn [a_Pat, b_Pat]), d_Pat] [] ( - If (App (App (Var inRange_PN) c_Expr) d_Expr) ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(d_PN, dh_PN)] ( + = mk_easy_FunMonoBind tycon_loc index_RDR + [AsPatIn c_RDR (TuplePatIn [a_Pat, b_Pat] True{-boxed-}), + d_Pat] [] ( + HsIf (HsPar (mk_easy_App inRange_RDR [c_RDR, d_RDR])) ( + untag_Expr tycon [(a_RDR, ah_RDR)] ( + untag_Expr tycon [(d_RDR, dh_RDR)] ( let - grhs = [OtherwiseGRHS (App (Var mkInt_PN) (Var c_PN)) mkGeneratedSrcLoc] + grhs = unguardedRHS (mk_easy_App mkInt_RDR [c_RDR]) tycon_loc in - Case (OpApp (Var dh_PN) (Var minusH_PN) (Var ah_PN)) {-of-} - [PatMatch (VarPatIn c_PN) + HsCase + (genOpApp (HsVar dh_RDR) minusH_RDR (HsVar ah_RDR)) + [PatMatch (VarPatIn c_RDR) (GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))] + tycon_loc )) ) {-else-} ( - App (Var error_PN) (Lit (StringLit (_PK_ ("Ix."++tycon_str++".index: out of range\n")))) - ) + HsApp (HsVar error_RDR) (HsLit (HsString (_PK_ ("Ix."++tycon_str++".index: out of range\n")))) ) + tycon_loc) enum_inRange - = mk_easy_FunMonoBind inRange_PN [TuplePatIn [a_Pat, b_Pat], c_Pat] [] ( - untag_Expr tycon [(a_PN, ah_PN)] ( - untag_Expr tycon [(b_PN, bh_PN)] ( - untag_Expr tycon [(c_PN, ch_PN)] ( - If (OpApp (Var ch_PN) (Var geH_PN) (Var ah_PN)) ( - (OpApp (Var ch_PN) (Var leH_PN) (Var bh_PN)) + = mk_easy_FunMonoBind tycon_loc inRange_RDR + [TuplePatIn [a_Pat, b_Pat] True{-boxed-}, c_Pat] [] ( + untag_Expr tycon [(a_RDR, ah_RDR)] ( + untag_Expr tycon [(b_RDR, bh_RDR)] ( + untag_Expr tycon [(c_RDR, ch_RDR)] ( + HsIf (genOpApp (HsVar ch_RDR) geH_RDR (HsVar ah_RDR)) ( + (genOpApp (HsVar ch_RDR) leH_RDR (HsVar bh_RDR)) ) {-else-} ( false_Expr - ))))) + ) tycon_loc)))) -------------------------------------------------------------- - single_con_ixes = single_con_range `AndMonoBinds` - single_con_index `AndMonoBinds` single_con_inRange + single_con_ixes + = single_con_range `AndMonoBinds` + single_con_index `AndMonoBinds` + single_con_inRange data_con - = case maybeSingleConstructorTyCon tycon of -- just checking... + = case maybeTyConSingleCon tycon of -- just checking... Nothing -> panic "get_Ix_binds" - Just dc -> let - (_, _, arg_tys, _) = getDataConSig dc - in - if any isPrimType arg_tys then + Just dc -> if (any isUnLiftedType (dataConRawArgTys dc)) then error ("ERROR: Can't derive Ix for a single-constructor type with primitive argument types: "++tycon_str) else dc - con_arity = getDataConArity data_con - data_con_PN = Prel (WiredInVal data_con) - con_pat xs = ConPatIn data_con_PN (map VarPatIn xs) - con_expr xs = foldl App (Var data_con_PN) (map Var xs) + con_arity = argFieldCount data_con + data_con_RDR = qual_orig_name data_con + + as_needed = take con_arity as_RDRs + bs_needed = take con_arity bs_RDRs + cs_needed = take con_arity cs_RDRs - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - cs_needed = take (getDataConArity data_con) cs_PNs + con_pat xs = ConPatIn data_con_RDR (map VarPatIn xs) + con_expr = mk_easy_App data_con_RDR cs_needed -------------------------------------------------------------- single_con_range - = mk_easy_FunMonoBind range_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed]] [] ( - ListComp (con_expr cs_needed) (zipWith3 mk_qual as_needed bs_needed cs_needed) - ) + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePatIn [con_pat as_needed, con_pat bs_needed] True{-boxed-}] [] $ + HsDo ListComp stmts tycon_loc where - mk_qual a b c = GeneratorQual (VarPatIn c) - (App (Var range_PN) (ExplicitTuple [Var a, Var b])) + stmts = zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed + ++ + [ReturnStmt con_expr] + + mk_qual a b c = BindStmt (VarPatIn c) + (HsApp (HsVar range_RDR) + (ExplicitTuple [HsVar a, HsVar b] True)) + tycon_loc ---------------- single_con_index - = mk_easy_FunMonoBind index_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] [range_size] ( - foldl mk_index (Lit (IntLit 0)) (zip3 as_needed bs_needed cs_needed)) + = mk_easy_FunMonoBind tycon_loc index_RDR + [TuplePatIn [con_pat as_needed, con_pat bs_needed] True, + con_pat cs_needed] [range_size] ( + foldl mk_index (HsLit (HsInt 0)) (zip3 as_needed bs_needed cs_needed)) where mk_index multiply_by (l, u, i) - =OpApp ( - (App (App (Var index_PN) (ExplicitTuple [Var l, Var u])) (Var i)) - ) (Var plus_PN) ( - OpApp ( - (App (Var rangeSize_PN) (ExplicitTuple [Var l, Var u])) - ) (Var times_PN) multiply_by + = genOpApp ( + (HsApp (HsApp (HsVar index_RDR) + (ExplicitTuple [HsVar l, HsVar u] True)) (HsVar i)) + ) plus_RDR ( + genOpApp ( + (HsApp (HsVar rangeSize_RDR) + (ExplicitTuple [HsVar l, HsVar u] True)) + ) times_RDR multiply_by ) range_size - = mk_easy_FunMonoBind rangeSize_PN [TuplePatIn [a_Pat, b_Pat]] [] ( - OpApp ( - (App (App (Var index_PN) (ExplicitTuple [a_Expr, b_Expr])) b_Expr) - ) (Var plus_PN) (Lit (IntLit 1))) + = mk_easy_FunMonoBind tycon_loc rangeSize_RDR + [TuplePatIn [a_Pat, b_Pat] True] [] ( + genOpApp ( + (HsApp (HsApp (HsVar index_RDR) + (ExplicitTuple [a_Expr, b_Expr] True)) b_Expr) + ) plus_RDR (HsLit (HsInt 1))) ------------------ single_con_inRange - = mk_easy_FunMonoBind inRange_PN [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] [] ( - foldl1 and_Expr (zipWith3 in_range as_needed bs_needed cs_needed)) + = mk_easy_FunMonoBind tycon_loc inRange_RDR + [TuplePatIn [con_pat as_needed, con_pat bs_needed] True, + con_pat cs_needed] + [] ( + foldl1 and_Expr (zipWith3Equal "single_con_inRange" in_range as_needed bs_needed cs_needed)) where - in_range a b c = App (App (Var inRange_PN) (ExplicitTuple [Var a, Var b])) (Var c) + in_range a b c = HsApp (HsApp (HsVar inRange_RDR) + (ExplicitTuple [HsVar a, HsVar b] True)) + (HsVar c) \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Text]{Generating @Text@ instance declarations} +\subsubsection{Generating @Read@ instance declarations} %* * %************************************************************************ -Deriving @Text@ is a pain. @show@ is commonly used; @read@ is rarely -used---but we're supposed to generate massive amounts of code for it -anyway. We provide a command-line flag to say ``Don't bother'' -(@OmitDerivedRead@). - -We just use the default methods for @showList@ and @readList@. - -Also: ignoring all the infix-ery mumbo jumbo (ToDo) - -The part of the Haskell report that deals with this (pages~147--151, -1.2~version) is an adequate guide to what needs to be done. Note that -this is where we may (eventually) use the fixity info that's been -passed around. +Ignoring all the infix-ery mumbo jumbo (ToDo) \begin{code} -gen_Text_binds :: [RenamedFixityDecl] -> Bool -> TyCon -> ProtoNameMonoBinds +gen_Read_binds :: TyCon -> RdrNameMonoBinds -gen_Text_binds fixities omit_derived_read tycon - = if omit_derived_read - then shows_prec - else shows_prec `AndMonoBinds` reads_prec +gen_Read_binds tycon + = reads_prec `AndMonoBinds` read_list where + tycon_loc = getSrcLoc tycon ----------------------------------------------------------------------- - shows_prec - = mk_FunMonoBind showsPrec_PN (map pats_etc (getTyConDataCons tycon)) - where - pats_etc data_con - = let - data_con_PN = Prel (WiredInVal data_con) - bs_needed = take (getDataConArity data_con) bs_PNs - con_pat = ConPatIn data_con_PN (map VarPatIn bs_needed) - is_nullary_con = isNullaryDataCon data_con - - show_con - = let (mod, nm) = getOrigName data_con - space_maybe = if is_nullary_con then _NIL_ else SLIT(" ") - in - App (Var showString_PN) (Lit (StringLit (nm _APPEND_ space_maybe))) - - show_thingies = show_con : (spacified real_show_thingies) - - real_show_thingies - = [ App (App (Var showsPrec_PN) (Lit (IntLit 10))) (Var b) - | b <- bs_needed ] - in - if is_nullary_con then -- skip the showParen junk... - ASSERT(null bs_needed) - ([a_Pat, con_pat], show_con) - else - ([a_Pat, con_pat], - showParen_Expr (OpApp a_Expr (Var ge_PN) (Lit (IntLit 10))) - (nested_compose_Expr show_thingies)) - where - spacified [] = [] - spacified [x] = [x] - spacified (x:xs) = (x : (Var showSpace_PN) : spacified xs) - + read_list = mk_easy_FunMonoBind tycon_loc readList_RDR [] [] + (HsApp (HsVar readList___RDR) (HsPar (HsApp (HsVar readsPrec_RDR) (HsLit (HsInt 0))))) ----------------------------------------------------------------------- - reads_prec -- ignore the infix game altogether + reads_prec = let read_con_comprehensions - = map read_con (getTyConDataCons tycon) + = map read_con (tyConDataCons tycon) in - mk_easy_FunMonoBind readsPrec_PN [a_Pat, b_Pat] [] ( - foldl1 append_Expr read_con_comprehensions + mk_easy_FunMonoBind tycon_loc readsPrec_RDR [a_Pat, b_Pat] [] ( + foldr1 append_Expr read_con_comprehensions ) where read_con data_con -- note: "b" is the string being "read" = let - data_con_PN = Prel (WiredInVal data_con) - data_con_str= snd (getOrigName data_con) - as_needed = take (getDataConArity data_con) as_PNs - bs_needed = take (getDataConArity data_con) bs_PNs - con_expr = foldl App (Var data_con_PN) (map Var as_needed) - is_nullary_con = isNullaryDataCon data_con - + data_con_RDR = qual_orig_name data_con + data_con_str= occNameString (getOccName data_con) + con_arity = argFieldCount data_con + con_expr = mk_easy_App data_con_RDR as_needed + nullary_con = con_arity == 0 + labels = dataConFieldLabels data_con + lab_fields = length labels + + as_needed = take con_arity as_RDRs + bs_needed + | lab_fields == 0 = take con_arity bs_RDRs + | otherwise = take (4*lab_fields + 1) bs_RDRs + -- (label, '=' and field)*n, (n-1)*',' + '{' + '}' con_qual - = GeneratorQual - (TuplePatIn [LitPatIn (StringLit data_con_str), d_Pat]) - (App (Var lex_PN) c_Expr) - - field_quals = snd (mapAccumL mk_qual d_Expr (as_needed `zip` bs_needed)) - + = BindStmt + (TuplePatIn [LitPatIn (HsString data_con_str), + d_Pat] True) + (HsApp (HsVar lex_RDR) c_Expr) + tycon_loc + + str_qual str res draw_from + = BindStmt + (TuplePatIn [LitPatIn (HsString str), VarPatIn res] True) + (HsApp (HsVar lex_RDR) draw_from) + tycon_loc + + read_label f + = let nm = occNameString (getOccName (fieldLabelName f)) + in + [str_qual nm, str_qual SLIT("=")] + -- There might be spaces between the label and '=' + + field_quals + | lab_fields == 0 = + snd (mapAccumL mk_qual + d_Expr + (zipWithEqual "as_needed" + (\ con_field draw_from -> (mk_read_qual con_field, + draw_from)) + as_needed bs_needed)) + | otherwise = + snd $ + mapAccumL mk_qual d_Expr + (zipEqual "bs_needed" + ((str_qual (SLIT("{")): + concat ( + intersperse ([str_qual (_CONS_ ',' _NIL_)]) $ + zipWithEqual + "field_quals" + (\ as b -> as ++ [b]) + -- The labels + (map read_label labels) + -- The fields + (map mk_read_qual as_needed))) ++ [str_qual (SLIT("}"))]) + bs_needed) + + mk_qual draw_from (f, str_left) + = (HsVar str_left, -- what to draw from down the line... + f str_left draw_from) + + mk_read_qual con_field res draw_from = + BindStmt + (TuplePatIn [VarPatIn con_field, VarPatIn res] True) + (HsApp (HsApp (HsVar readsPrec_RDR) (HsLit (HsInt 10))) draw_from) + tycon_loc + + result_expr = ExplicitTuple [con_expr, if null bs_needed + then d_Expr + else HsVar (last bs_needed)] True + + stmts = con_qual:field_quals ++ [ReturnStmt result_expr] + read_paren_arg - = if is_nullary_con then -- must be False (parens are surely optional) + = if nullary_con then -- must be False (parens are surely optional) false_Expr else -- parens depend on precedence... - OpApp a_Expr (Var gt_PN) (Lit (IntLit 9)) + HsPar (genOpApp a_Expr gt_RDR (HsLit (HsInt 9))) in - App ( - readParen_Expr read_paren_arg ( - Lam (mk_easy_Match [c_Pat] [] ( - ListComp (ExplicitTuple [con_expr, - if null bs_needed then d_Expr else Var (last bs_needed)]) - (con_qual : field_quals))) - )) (Var b_PN) - where - mk_qual draw_from (con_field, str_left) - = (Var str_left, -- what to draw from down the line... - GeneratorQual - (TuplePatIn [VarPatIn con_field, VarPatIn str_left]) - (App (App (Var readsPrec_PN) (Lit (IntLit 10))) draw_from)) + HsApp ( + readParen_Expr read_paren_arg $ HsPar $ + HsLam (mk_easy_Match tycon_loc [c_Pat] [] $ + HsDo ListComp stmts tycon_loc) + ) (HsVar b_RDR) + \end{code} %************************************************************************ %* * -\subsubsection[TcGenDeriv-Binary]{Generating @Binary@ instance declarations} +\subsubsection{Generating @Show@ instance declarations} %* * %************************************************************************ -ToDo: NOT DONE YET. +Ignoring all the infix-ery mumbo jumbo (ToDo) \begin{code} -gen_Binary_binds :: TyCon -> ProtoNameMonoBinds +gen_Show_binds :: TyCon -> RdrNameMonoBinds + +gen_Show_binds tycon + = shows_prec `AndMonoBinds` show_list + where + tycon_loc = getSrcLoc tycon + ----------------------------------------------------------------------- + show_list = mk_easy_FunMonoBind tycon_loc showList_RDR [] [] + (HsApp (HsVar showList___RDR) (HsPar (HsApp (HsVar showsPrec_RDR) (HsLit (HsInt 0))))) + ----------------------------------------------------------------------- + shows_prec + = mk_FunMonoBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon)) + where + pats_etc data_con + = let + data_con_RDR = qual_orig_name data_con + con_arity = argFieldCount data_con + bs_needed = take con_arity bs_RDRs + con_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed) + nullary_con = con_arity == 0 + labels = dataConFieldLabels data_con + lab_fields = length labels + + show_con + = let nm = occNameString (getOccName data_con) + space_ocurly_maybe + | nullary_con = _NIL_ + | lab_fields == 0 = SLIT(" ") + | otherwise = SLIT("{") -gen_Binary_binds tycon - = panic "gen_Binary_binds" + in + mk_showString_app (nm _APPEND_ space_ocurly_maybe) + + show_all con fs + = let + ccurly_maybe + | lab_fields > 0 = [mk_showString_app (SLIT("}"))] + | otherwise = [] + in + con:fs ++ ccurly_maybe + + show_thingies = show_all show_con real_show_thingies_with_labs + + show_label l + = let nm = occNameString (getOccName (fieldLabelName l)) + in + mk_showString_app (nm _APPEND_ SLIT("=")) + + mk_showString_app str = HsApp (HsVar showString_RDR) + (HsLit (HsString str)) + + real_show_thingies = + [ HsApp (HsApp (HsVar showsPrec_RDR) (HsLit (HsInt 10))) (HsVar b) + | b <- bs_needed ] + + real_show_thingies_with_labs + | lab_fields == 0 = intersperse (HsVar showSpace_RDR) real_show_thingies + | otherwise = --Assumption: no of fields == no of labelled fields + -- (and in same order) + concat $ + intersperse ([mk_showString_app (_CONS_ ',' _NIL_)]) $ -- Using SLIT()s containing ,s spells trouble. + zipWithEqual "gen_Show_binds" + (\ a b -> [a,b]) + (map show_label labels) + real_show_thingies + + + in + if nullary_con then -- skip the showParen junk... + ASSERT(null bs_needed) + ([a_Pat, con_pat], show_con) + else + ([a_Pat, con_pat], + showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt 10)))) + (HsPar (nested_compose_Expr show_thingies))) \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-con2tag-tag2con]{Generating extra binds (@con2tag@ and @tag2con@)} +\subsection{Generating extra binds (@con2tag@ and @tag2con@)} %* * %************************************************************************ @@ -771,46 +919,48 @@ The `tags' here start at zero, hence the @fIRST_TAG@ (currently one) fiddling around. \begin{code} +data TagThingWanted + = GenCon2Tag | GenTag2Con | GenMaxTag + gen_tag_n_con_monobind - :: (ProtoName, Name, -- (proto)Name for the thing in question + :: (RdrName, -- (proto)Name for the thing in question TyCon, -- tycon in question TagThingWanted) - -> ProtoNameMonoBinds + -> RdrNameMonoBinds -gen_tag_n_con_monobind (pn, _, tycon, GenCon2Tag) - = mk_FunMonoBind pn (map mk_stuff (getTyConDataCons tycon)) +gen_tag_n_con_monobind (rdr_name, tycon, GenCon2Tag) + = mk_FunMonoBind (getSrcLoc tycon) rdr_name (map mk_stuff (tyConDataCons tycon)) where - mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameExpr) + mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) mk_stuff var - = ASSERT(isDataCon var) - ([pat], Lit (IntPrimLit (toInteger ((getDataConTag var) - fIRST_TAG)))) + = ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))) where - pat = ConPatIn var_PN (nOfThem (getDataConArity var) WildPatIn) - var_PN = Prel (WiredInVal var) + pat = ConPatIn var_RDR (nOfThem (argFieldCount var) WildPatIn) + var_RDR = qual_orig_name var -gen_tag_n_con_monobind (pn, _, tycon, GenTag2Con) - = mk_FunMonoBind pn (map mk_stuff (getTyConDataCons tycon)) +gen_tag_n_con_monobind (rdr_name, tycon, GenTag2Con) + = mk_FunMonoBind (getSrcLoc tycon) rdr_name (map mk_stuff (tyConDataCons tycon) ++ + [([WildPatIn], impossible_Expr)]) where - mk_stuff :: DataCon -> ([ProtoNamePat], ProtoNameExpr) - - mk_stuff var - = ASSERT(isDataCon var) - ([lit_pat], Var var_PN) + mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) + mk_stuff var = ([lit_pat], HsVar var_RDR) where - lit_pat = ConPatIn mkInt_PN [LitPatIn (IntPrimLit (toInteger ((getDataConTag var) - fIRST_TAG)))] - var_PN = Prel (WiredInVal var) + lit_pat = ConPatIn mkInt_RDR [LitPatIn (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))] + var_RDR = qual_orig_name var -gen_tag_n_con_monobind (pn, _, tycon, GenMaxTag) - = mk_easy_FunMonoBind pn [] [] (App (Var mkInt_PN) (Lit (IntPrimLit max_tag))) +gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag) + = mk_easy_FunMonoBind (getSrcLoc tycon) + rdr_name [] [] (HsApp (HsVar mkInt_RDR) (HsLit (HsIntPrim max_tag))) where - max_tag = case (getTyConDataCons tycon) of + max_tag = case (tyConDataCons tycon) of data_cons -> toInteger ((length data_cons) - fIRST_TAG) + \end{code} %************************************************************************ %* * -\subsection[TcGenDeriv-bind-utils]{Utility bits for generating bindings} +\subsection{Utility bits for generating bindings} %* * %************************************************************************ @@ -829,256 +979,235 @@ multi-clause definitions; it generates: \end{verbatim} \begin{code} -mk_easy_FunMonoBind :: ProtoName -> [ProtoNamePat] - -> [ProtoNameMonoBinds] -> ProtoNameExpr - -> ProtoNameMonoBinds +mk_easy_FunMonoBind :: SrcLoc -> RdrName -> [RdrNamePat] + -> [RdrNameMonoBinds] -> RdrNameHsExpr + -> RdrNameMonoBinds -mk_easy_FunMonoBind fun pats binds expr - = FunMonoBind fun [mk_easy_Match pats binds expr] mkGeneratedSrcLoc +mk_easy_FunMonoBind loc fun pats binds expr + = FunMonoBind fun False{-not infix-} [mk_easy_Match loc pats binds expr] loc -mk_easy_Match pats binds expr - = foldr PatMatch - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] (mkbind binds))) - pats +mk_easy_Match loc pats binds expr + = mk_match loc pats expr (mkbind binds) where - mkbind [] = EmptyBinds - mkbind bs = SingleBind (RecBind (foldr1 AndMonoBinds bs)) + mkbind [] = EmptyBinds + mkbind bs = MonoBind (foldr1 AndMonoBinds bs) [] Recursive -- The renamer expects everything in its input to be a -- "recursive" MonoBinds, and it is its job to sort things out -- from there. -mk_FunMonoBind :: ProtoName - -> [([ProtoNamePat], ProtoNameExpr)] - -> ProtoNameMonoBinds +mk_FunMonoBind :: SrcLoc -> RdrName + -> [([RdrNamePat], RdrNameHsExpr)] + -> RdrNameMonoBinds + +mk_FunMonoBind loc fun [] = panic "TcGenDeriv:mk_FunMonoBind" +mk_FunMonoBind loc fun pats_and_exprs + = FunMonoBind fun False{-not infix-} + [ mk_match loc p e EmptyBinds | (p,e) <-pats_and_exprs ] + loc -mk_FunMonoBind fun [] = panic "TcGenDeriv:mk_FunMonoBind" -mk_FunMonoBind fun pats_and_exprs - = FunMonoBind fun (map mk_match pats_and_exprs) mkGeneratedSrcLoc +mk_match loc pats expr binds + = foldr PatMatch + (GRHSMatch (GRHSsAndBindsIn (unguardedRHS expr loc) binds)) + (map paren pats) where - mk_match (pats, expr) - = foldr PatMatch - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr mkGeneratedSrcLoc] EmptyBinds)) - pats + paren p@(VarPatIn _) = p + paren other_p = ParPatIn other_p \end{code} \begin{code} -tagCmp_Case, cmp_eq_Expr :: - ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr -tagCmp_gen_Case :: - ProtoName - -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr -careful_tagCmp_Case :: -- checks for primitive types... - UniType - -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr - -tagCmp_Case = tagCmp_gen_Case tagCmp_PN -cmp_eq_Expr = tagCmp_gen_Case cmp_eq_PN - -tagCmp_gen_Case fun lt eq gt a b - = Case (App (App (Var fun) a) b) {-of-} - [PatMatch (ConPatIn lt_TAG_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS lt mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn eq_TAG_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS eq mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn gt_TAG_PN []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS gt mkGeneratedSrcLoc] EmptyBinds))] - -careful_tagCmp_Case ty lt eq gt a b - = if not (isPrimType ty) then - tagCmp_gen_Case tagCmp_PN lt eq gt a b +mk_easy_App f xs = foldl HsApp (HsVar f) (map HsVar xs) +\end{code} + +ToDo: Better SrcLocs. + +\begin{code} +compare_Case, cmp_eq_Expr :: + RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr +compare_gen_Case :: + RdrName + -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr +careful_compare_Case :: -- checks for primitive types... + Type + -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr + +compare_Case = compare_gen_Case compare_RDR +cmp_eq_Expr = compare_gen_Case cmp_eq_RDR + +compare_gen_Case fun lt eq gt a b + = HsCase (HsPar (HsApp (HsApp (HsVar fun) a) b)) {-of-} + [PatMatch (ConPatIn ltTag_RDR []) + (GRHSMatch (GRHSsAndBindsIn (unguardedRHS lt mkGeneratedSrcLoc) EmptyBinds)), + + PatMatch (ConPatIn eqTag_RDR []) + (GRHSMatch (GRHSsAndBindsIn (unguardedRHS eq mkGeneratedSrcLoc) EmptyBinds)), + + PatMatch (ConPatIn gtTag_RDR []) + (GRHSMatch (GRHSsAndBindsIn (unguardedRHS gt mkGeneratedSrcLoc) EmptyBinds))] + mkGeneratedSrcLoc + +careful_compare_Case ty lt eq gt a b + = if not (isUnboxedType ty) then + compare_gen_Case compare_RDR lt eq gt a b else -- we have to do something special for primitive things... - If (OpApp a (Var relevant_eq_op) b) - eq - (If (OpApp a (Var relevant_lt_op) b) lt gt) + HsIf (genOpApp a relevant_eq_op b) + eq + (HsIf (genOpApp a relevant_lt_op b) lt gt mkGeneratedSrcLoc) + mkGeneratedSrcLoc where - relevant_eq_op = assoc "careful_tagCmp_Case" eq_op_tbl ty - relevant_lt_op = assoc "careful_tagCmp_Case" lt_op_tbl ty - -eq_op_tbl = [ - (charPrimTy, Prel (WiredInVal (primOpId CharEqOp))), - (intPrimTy, Prel (WiredInVal (primOpId IntEqOp))), - (wordPrimTy, Prel (WiredInVal (primOpId WordEqOp))), - (addrPrimTy, Prel (WiredInVal (primOpId AddrEqOp))), - (floatPrimTy, Prel (WiredInVal (primOpId FloatEqOp))), - (doublePrimTy, Prel (WiredInVal (primOpId DoubleEqOp))) ] - -lt_op_tbl = [ - (charPrimTy, Prel (WiredInVal (primOpId CharLtOp))), - (intPrimTy, Prel (WiredInVal (primOpId IntLtOp))), - (wordPrimTy, Prel (WiredInVal (primOpId WordLtOp))), - (addrPrimTy, Prel (WiredInVal (primOpId AddrLtOp))), - (floatPrimTy, Prel (WiredInVal (primOpId FloatLtOp))), - (doublePrimTy, Prel (WiredInVal (primOpId DoubleLtOp))) ] + relevant_eq_op = assoc_ty_id eq_op_tbl ty + relevant_lt_op = assoc_ty_id lt_op_tbl ty + +assoc_ty_id tyids ty + = if null res then panic "assoc_ty" + else head res + where + res = [id | (ty',id) <- tyids, ty == ty'] + +eq_op_tbl = + [(charPrimTy, eqH_Char_RDR) + ,(intPrimTy, eqH_Int_RDR) + ,(wordPrimTy, eqH_Word_RDR) + ,(addrPrimTy, eqH_Addr_RDR) + ,(floatPrimTy, eqH_Float_RDR) + ,(doublePrimTy, eqH_Double_RDR) + ] + +lt_op_tbl = + [(charPrimTy, ltH_Char_RDR) + ,(intPrimTy, ltH_Int_RDR) + ,(wordPrimTy, ltH_Word_RDR) + ,(addrPrimTy, ltH_Addr_RDR) + ,(floatPrimTy, ltH_Float_RDR) + ,(doublePrimTy, ltH_Double_RDR) + ] ----------------------------------------------------------------------- -and_Expr, append_Expr :: ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr +and_Expr, append_Expr :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -and_Expr a b = OpApp a (Var and_PN) b -append_Expr a b = OpApp a (Var append_PN) b +and_Expr a b = genOpApp a and_RDR b +append_Expr a b = genOpApp a append_RDR b ----------------------------------------------------------------------- -eq_Expr :: UniType -> ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr +eq_Expr :: Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr eq_Expr ty a b - = if not (isPrimType ty) then - OpApp a (Var eq_PN) b + = if not (isUnboxedType ty) then + genOpApp a eq_RDR b else -- we have to do something special for primitive things... - OpApp a (Var relevant_eq_op) b + genOpApp a relevant_eq_op b where - relevant_eq_op = assoc "eq_Expr" eq_op_tbl ty + relevant_eq_op = assoc_ty_id eq_op_tbl ty +\end{code} + +\begin{code} +argFieldCount :: DataCon -> Int -- Works on data and newtype constructors +argFieldCount con = length (dataConRawArgTys con) \end{code} \begin{code} -untag_Expr :: TyCon -> [(ProtoName, ProtoName)] -> ProtoNameExpr -> ProtoNameExpr +untag_Expr :: TyCon -> [(RdrName, RdrName)] -> RdrNameHsExpr -> RdrNameHsExpr untag_Expr tycon [] expr = expr untag_Expr tycon ((untag_this, put_tag_here) : more) expr - = Case (App (con2tag_Expr tycon) (Var untag_this)) {-of-} + = HsCase (HsPar (HsApp (con2tag_Expr tycon) (HsVar untag_this))) {-of-} [PatMatch (VarPatIn put_tag_here) (GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))] + mkGeneratedSrcLoc where - grhs = [OtherwiseGRHS (untag_Expr tycon more expr) mkGeneratedSrcLoc] + grhs = unguardedRHS (untag_Expr tycon more expr) mkGeneratedSrcLoc -cmp_tags_Expr :: ProtoName -- Comparison op - -> ProtoName -> ProtoName -- Things to compare - -> ProtoNameExpr -- What to return if true - -> ProtoNameExpr -- What to return if false - -> ProtoNameExpr +cmp_tags_Expr :: RdrName -- Comparison op + -> RdrName -> RdrName -- Things to compare + -> RdrNameHsExpr -- What to return if true + -> RdrNameHsExpr -- What to return if false + -> RdrNameHsExpr -cmp_tags_Expr op a b true_case false_case - = If (OpApp (Var a) (Var op) (Var b)) true_case false_case +cmp_tags_Expr op a b true_case false_case + = HsIf (genOpApp (HsVar a) op (HsVar b)) true_case false_case mkGeneratedSrcLoc enum_from_to_Expr - :: ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr + :: RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr enum_from_then_to_Expr - :: ProtoNameExpr -> ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr + :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -enum_from_to_Expr f t2 = App (App (Var enumFromTo_PN) f) t2 -enum_from_then_to_Expr f t t2 = App (App (App (Var enumFromThenTo_PN) f) t) t2 +enum_from_to_Expr f t2 = HsApp (HsApp (HsVar enumFromTo_RDR) f) t2 +enum_from_then_to_Expr f t t2 = HsApp (HsApp (HsApp (HsVar enumFromThenTo_RDR) f) t) t2 showParen_Expr, readParen_Expr - :: ProtoNameExpr -> ProtoNameExpr - -> ProtoNameExpr + :: RdrNameHsExpr -> RdrNameHsExpr + -> RdrNameHsExpr -showParen_Expr e1 e2 = App (App (Var showParen_PN) e1) e2 -readParen_Expr e1 e2 = App (App (Var readParen_PN) e1) e2 +showParen_Expr e1 e2 = HsApp (HsApp (HsVar showParen_RDR) e1) e2 +readParen_Expr e1 e2 = HsApp (HsApp (HsVar readParen_RDR) e1) e2 -nested_compose_Expr :: [ProtoNameExpr] -> ProtoNameExpr +nested_compose_Expr :: [RdrNameHsExpr] -> RdrNameHsExpr -nested_compose_Expr [e] = e +nested_compose_Expr [e] = parenify e nested_compose_Expr (e:es) - = App (App (Var compose_PN) e) (nested_compose_Expr es) -\end{code} + = HsApp (HsApp (HsVar compose_RDR) (parenify e)) (nested_compose_Expr es) -\begin{code} -a_PN = Unk SLIT("a") -b_PN = Unk SLIT("b") -c_PN = Unk SLIT("c") -d_PN = Unk SLIT("d") -ah_PN = Unk SLIT("a#") -bh_PN = Unk SLIT("b#") -ch_PN = Unk SLIT("c#") -dh_PN = Unk SLIT("d#") -cmp_eq_PN = Unk SLIT("cmp_eq") -rangeSize_PN = Unk SLIT("rangeSize") - -as_PNs = [ Unk (_PK_ ("a"++show i)) | i <- [(1::Int) .. ] ] -bs_PNs = [ Unk (_PK_ ("b"++show i)) | i <- [(1::Int) .. ] ] -cs_PNs = [ Unk (_PK_ ("c"++show i)) | i <- [(1::Int) .. ] ] - -eq_PN = prelude_method SLIT("Eq") SLIT("==") -ne_PN = prelude_method SLIT("Eq") SLIT("/=") -le_PN = prelude_method SLIT("Ord") SLIT("<=") -lt_PN = prelude_method SLIT("Ord") SLIT("<") -ge_PN = prelude_method SLIT("Ord") SLIT(">=") -gt_PN = prelude_method SLIT("Ord") SLIT(">") -max_PN = prelude_method SLIT("Ord") SLIT("max") -min_PN = prelude_method SLIT("Ord") SLIT("min") -tagCmp_PN = prelude_method SLIT("Ord") SLIT("_tagCmp") -lt_TAG_PN = Prel (WiredInVal ltPrimDataCon) -eq_TAG_PN = Prel (WiredInVal eqPrimDataCon) -gt_TAG_PN = Prel (WiredInVal gtPrimDataCon) -enumFrom_PN = prelude_method SLIT("Enum") SLIT("enumFrom") -enumFromTo_PN = prelude_method SLIT("Enum") SLIT("enumFromTo") -enumFromThen_PN = prelude_method SLIT("Enum") SLIT("enumFromThen") -enumFromThenTo_PN= prelude_method SLIT("Enum") SLIT("enumFromThenTo") -range_PN = prelude_method SLIT("Ix") SLIT("range") -index_PN = prelude_method SLIT("Ix") SLIT("index") -inRange_PN = prelude_method SLIT("Ix") SLIT("inRange") -readsPrec_PN = prelude_method SLIT("Text") SLIT("readsPrec") -showsPrec_PN = prelude_method SLIT("Text") SLIT("showsPrec") -plus_PN = prelude_method SLIT("Num") SLIT("+") -times_PN = prelude_method SLIT("Num") SLIT("*") - -false_PN = Prel (WiredInVal falseDataCon) -true_PN = Prel (WiredInVal trueDataCon) -eqH_PN = Prel (WiredInVal (primOpId IntEqOp)) -geH_PN = Prel (WiredInVal (primOpId IntGeOp)) -leH_PN = Prel (WiredInVal (primOpId IntLeOp)) -ltH_PN = Prel (WiredInVal (primOpId IntLtOp)) -minusH_PN = Prel (WiredInVal (primOpId IntSubOp)) -and_PN = prelude_val pRELUDE SLIT("&&") -not_PN = prelude_val pRELUDE SLIT("not") -append_PN = prelude_val pRELUDE_LIST SLIT("++") -map_PN = prelude_val pRELUDE_LIST SLIT("map") -compose_PN = prelude_val pRELUDE SLIT(".") -mkInt_PN = Prel (WiredInVal intDataCon) -error_PN = Prel (WiredInVal eRROR_ID) -showSpace_PN = prelude_val pRELUDE_TEXT SLIT("showSpace__") -- not quite std -showString_PN = prelude_val pRELUDE_TEXT SLIT("showString") -showParen_PN = prelude_val pRELUDE_TEXT SLIT("showParen") -readParen_PN = prelude_val pRELUDE_TEXT SLIT("readParen") -lex_PN = prelude_val pRELUDE_TEXT SLIT("lex") - -prelude_val m s = Imp m s [m] s -prelude_method c o = Imp pRELUDE_CORE o [pRELUDE_CORE] o -- class not used... - -a_Expr = Var a_PN -b_Expr = Var b_PN -c_Expr = Var c_PN -d_Expr = Var d_PN -lt_TAG_Expr = Var lt_TAG_PN -eq_TAG_Expr = Var eq_TAG_PN -gt_TAG_Expr = Var gt_TAG_PN -false_Expr = Var false_PN -true_Expr = Var true_PN - -con2tag_Expr tycon = Var (con2tag_PN tycon) - -a_Pat = VarPatIn a_PN -b_Pat = VarPatIn b_PN -c_Pat = VarPatIn c_PN -d_Pat = VarPatIn d_PN -\end{code} +-- impossible_Expr is used in case RHSs that should never happen. +-- We generate these to keep the desugarer from complaining that they *might* happen! +impossible_Expr = HsApp (HsVar error_RDR) (HsLit (HsString (_PK_ "Urk! in TcGenDeriv"))) -%************************************************************************ -%* * -\subsection[TcGenDeriv-misc-utils]{Miscellaneous utility bits for deriving} -%* * -%************************************************************************ +parenify e@(HsVar _) = e +parenify e = HsPar e + +-- genOpApp wraps brackets round the operator application, so that the +-- renamer won't subsequently try to re-associate it. +-- For some reason the renamer doesn't reassociate it right, and I can't +-- be bothered to find out why just now. + +genOpApp e1 op e2 = mkOpApp e1 op e2 +\end{code} \begin{code} -{- UNUSED: -hasCon2TagFun :: TyCon -> Bool -hasCon2TagFun tycon - = preludeClassDerivedFor ordClassKey tycon - || isEnumerationTyConMostly tycon - -hasTag2ConFun :: TyCon -> Bool -hasTag2ConFun tycon - = isEnumerationTyCon tycon - && (preludeClassDerivedFor ixClassKey tycon - || preludeClassDerivedFor enumClassKey tycon) --} +qual_orig_name n = case modAndOcc n of { (m,n) -> Qual m n HiFile } + +a_RDR = varUnqual SLIT("a") +b_RDR = varUnqual SLIT("b") +c_RDR = varUnqual SLIT("c") +d_RDR = varUnqual SLIT("d") +ah_RDR = varUnqual SLIT("a#") +bh_RDR = varUnqual SLIT("b#") +ch_RDR = varUnqual SLIT("c#") +dh_RDR = varUnqual SLIT("d#") +cmp_eq_RDR = varUnqual SLIT("cmp_eq") +rangeSize_RDR = varUnqual SLIT("rangeSize") + +as_RDRs = [ varUnqual (_PK_ ("a"++show i)) | i <- [(1::Int) .. ] ] +bs_RDRs = [ varUnqual (_PK_ ("b"++show i)) | i <- [(1::Int) .. ] ] +cs_RDRs = [ varUnqual (_PK_ ("c"++show i)) | i <- [(1::Int) .. ] ] + +a_Expr = HsVar a_RDR +b_Expr = HsVar b_RDR +c_Expr = HsVar c_RDR +d_Expr = HsVar d_RDR +ltTag_Expr = HsVar ltTag_RDR +eqTag_Expr = HsVar eqTag_RDR +gtTag_Expr = HsVar gtTag_RDR +false_Expr = HsVar false_RDR +true_Expr = HsVar true_RDR + +con2tag_Expr tycon = HsVar (con2tag_RDR tycon) + +a_Pat = VarPatIn a_RDR +b_Pat = VarPatIn b_RDR +c_Pat = VarPatIn c_RDR +d_Pat = VarPatIn d_RDR + +con2tag_RDR, tag2con_RDR, maxtag_RDR :: TyCon -> RdrName + +con2tag_RDR tycon = varUnqual (SLIT("con2tag_") _APPEND_ occNameString (getOccName tycon) _APPEND_ SLIT("#")) +tag2con_RDR tycon = varUnqual (SLIT("tag2con_") _APPEND_ occNameString (getOccName tycon) _APPEND_ SLIT("#")) +maxtag_RDR tycon = varUnqual (SLIT("maxtag_") _APPEND_ occNameString (getOccName tycon) _APPEND_ SLIT("#")) \end{code}