X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcGenDeriv.lhs;h=9939a58ea574aa4a57e22bea4f0561fd52dd8d59;hb=7c72bad588294734ecf3590247c67e47f8ba63fd;hp=dde873ef589f95b1c0f3918cb105cb13196aa590;hpb=db2da00e8722919ecfbda79fe536af86b8bf045e;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcGenDeriv.lhs b/ghc/compiler/typecheck/TcGenDeriv.lhs index dde873e..9939a58 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-1996 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TcGenDeriv]{Generating derived instance declarations} @@ -9,12 +9,9 @@ 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 ( gen_Bounded_binds, gen_Enum_binds, - gen_Eval_binds, gen_Eq_binds, gen_Ix_binds, gen_Ord_binds, @@ -27,45 +24,49 @@ module TcGenDeriv ( TagThingWanted(..) ) where -IMP_Ubiq() -IMPORT_1_3(List(partition,intersperse)) +#include "HsVersions.h" -import HsSyn ( HsBinds(..), MonoBinds(..), Match(..), GRHSsAndBinds(..), - GRHS(..), HsExpr(..), HsLit(..), InPat(..), Stmt(..), DoOrListComp(..), - SYN_IE(RecFlag), recursive, - ArithSeqInfo, Sig, HsType, FixityDecl, Fixity, Fake ) -import RdrHsSyn ( RdrName(..), varQual, varUnqual, mkOpApp, - SYN_IE(RdrNameMonoBinds), SYN_IE(RdrNameHsExpr), SYN_IE(RdrNamePat) +import HsSyn ( InPat(..), HsExpr(..), MonoBinds(..), + Match(..), GRHSs(..), Stmt(..), HsLit(..), + HsBinds(..), HsType(..), HsMatchContext(..), + unguardedRHS, mkSimpleMatch, mkMonoBind, andMonoBindList + ) +import RdrHsSyn ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat ) +import RdrName ( RdrName, mkUnqual ) +import BasicTypes ( RecFlag(..), Fixity(..), FixityDirection(..) + , maxPrecedence, defaultFixity + , Boxity(..) ) -import BasicTypes ( IfaceFlavour(..) ) import FieldLabel ( fieldLabelName ) -import Id ( GenId, isNullaryDataCon, dataConTag, - dataConRawArgTys, fIRST_TAG, - isDataCon, SYN_IE(DataCon), SYN_IE(ConTag), - dataConFieldLabels, SYN_IE(Id) ) -import Maybes ( maybeToBool ) +import DataCon ( isNullaryDataCon, dataConTag, + dataConOrigArgTys, dataConSourceArity, fIRST_TAG, + DataCon, + dataConFieldLabels ) import Name ( getOccString, getOccName, getSrcLoc, occNameString, - modAndOcc, OccName, Name ) + occNameUserString, nameRdrName, varName, + Name, NamedThing(..), + isDataSymOcc, isSymOcc + ) -import PrimOp ( PrimOp(..) ) import PrelInfo -- Lots of RdrNames -import SrcLoc ( mkGeneratedSrcLoc, SrcLoc ) -import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, maybeTyConSingleCon ) -import Type ( eqTy, isPrimType, SYN_IE(Type) ) +import SrcLoc ( generatedSrcLoc, SrcLoc ) +import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, + maybeTyConSingleCon, tyConFamilySize + ) +import Type ( isUnLiftedType, Type ) import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, floatPrimTy, doublePrimTy ) import Util ( mapAccumL, zipEqual, zipWithEqual, - zipWith3Equal, nOfThem, panic, assertPanic ) - - -#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ <= 200 -intersperse :: a -> [a] -> [a] -intersperse s [] = [] -intersperse s [x] = [x] -intersperse s (x:xs) = x : s : intersperse s xs + zipWith3Equal, nOfThem ) +import Panic ( panic, assertPanic ) +import Maybes ( maybeToBool, orElse ) +import Constants +import List ( partition, intersperse ) + +#if __GLASGOW_HASKELL__ >= 404 +import GlaExts ( fromInt ) #endif - \end{code} %************************************************************************ @@ -101,7 +102,7 @@ data Foo ... = N1 | N2 ... | Nn | O1 a b | O2 Int | O3 Double b b | ... (==) (O3 a1 b1 c1) (O3 a2 b2 c2) = a1 == a2 && b1 == b2 && c1 == c2 \end{verbatim} - Note: if we're comparing unboxed things, e.g., if \tr{a1} and + Note: if we're comparing unlifted things, e.g., if \tr{a1} and \tr{a2} are \tr{Float#}s, then we have to generate \begin{verbatim} case (a1 `eqFloat#` a2) of @@ -147,6 +148,23 @@ instance ... Eq (Foo ...) where 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 -> RdrNameMonoBinds @@ -162,7 +180,7 @@ gen_Eq_binds tycon case maybeTyConSingleCon tycon of Just _ -> [] Nothing -> -- if cons don't match, then False - [([a_Pat, b_Pat], false_Expr)] + [([wildPat, wildPat], false_Expr)] else -- calc. and compare the tags [([a_Pat, b_Pat], untag_Expr tycon [(a_RDR,ah_RDR), (b_RDR,bh_RDR)] @@ -183,7 +201,7 @@ gen_Eq_binds tycon con_arity = length tys_needed as_needed = take con_arity as_RDRs bs_needed = take con_arity bs_RDRs - tys_needed = dataConRawArgTys data_con + tys_needed = dataConOrigArgTys data_con in ([con1_pat, con2_pat], nested_eq_expr tys_needed as_needed bs_needed) where @@ -269,9 +287,10 @@ cmp_eq (O3 a1 b1 c1) (O3 a2 b2 c2) } \end{verbatim} - Again, we must be careful about unboxed comparisons. For example, + Again, we must be careful about unlifted 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) = compareInt# a1 a2 @@ -286,11 +305,15 @@ 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 -> RdrNameMonoBinds gen_Ord_binds tycon - = defaulted `AndMonoBinds` compare + = compare -- `AndMonoBinds` compare + -- The default declaration in PrelBase handles this where tycon_loc = getSrcLoc tycon -------------------------------------------------------------------- @@ -298,7 +321,11 @@ gen_Ord_binds tycon [a_Pat, b_Pat] [cmp_eq] (if maybeToBool (maybeTyConSingleCon tycon) then - cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr + +-- cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr +-- Weird. Was: case (cmp a b) of { LT -> LT; EQ -> EQ; GT -> GT } + + cmp_eq_Expr a_Expr b_Expr else untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] (cmp_tags_Expr eqH_Int_RDR ah_RDR bh_RDR @@ -308,19 +335,38 @@ gen_Ord_binds tycon (if isEnumerationTyCon tycon then eqTag_Expr else - cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr +-- cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr +-- Ditto + cmp_eq_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_Int_RDR ah_RDR bh_RDR ltTag_Expr gtTag_Expr))) + tycon_data_cons = tyConDataCons tycon (nullary_cons, nonnullary_cons) | isNewTyCon tycon = ([], tyConDataCons tycon) - | otherwise = partition isNullaryDataCon (tyConDataCons tycon) - - cmp_eq - = mk_FunMonoBind tycon_loc cmp_eq_RDR (map pats_etc nonnullary_cons ++ - [([WildPatIn, WildPatIn], default_rhs)]) + | 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], @@ -333,7 +379,7 @@ gen_Ord_binds tycon con_arity = length tys_needed as_needed = take con_arity as_RDRs bs_needed = take con_arity bs_RDRs - tys_needed = dataConRawArgTys data_con + tys_needed = dataConOrigArgTys data_con nested_compare_expr [ty] [a] [b] = careful_compare_Case ty ltTag_Expr eqTag_Expr gtTag_Expr (HsVar a) (HsVar b) @@ -348,21 +394,24 @@ gen_Ord_binds tycon -- Tags are equal, no args => return EQ -------------------------------------------------------------------- +{- Not necessary: the default decls in PrelBase handle these + defaulted = foldr1 AndMonoBinds [lt, le, ge, gt, max_, min_] -lt = mk_easy_FunMonoBind mkGeneratedSrcLoc lt_RDR [a_Pat, b_Pat] [] ( +lt = mk_easy_FunMonoBind generatedSrcLoc 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] [] ( +le = mk_easy_FunMonoBind generatedSrcLoc 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] [] ( +ge = mk_easy_FunMonoBind generatedSrcLoc 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] [] ( +gt = mk_easy_FunMonoBind generatedSrcLoc 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] [] ( +max_ = mk_easy_FunMonoBind generatedSrcLoc 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] [] ( +min_ = mk_easy_FunMonoBind generatedSrcLoc min_RDR [a_Pat, b_Pat] [] ( compare_Case a_Expr b_Expr b_Expr a_Expr b_Expr) +-} \end{code} %************************************************************************ @@ -381,6 +430,9 @@ we use both @con2tag_Foo@ and @tag2con_Foo@ functions, as well as a \begin{verbatim} instance ... Enum (Foo ...) where + succ x = toEnum (1 + fromEnum x) + pred x = toEnum (fromEnum x - 1) + toEnum i = tag2con_Foo i enumFrom a = map tag2con_Foo [con2tag_Foo a .. maxtag_Foo] @@ -407,16 +459,54 @@ For @enumFromTo@ and @enumFromThenTo@, we use the default methods. gen_Enum_binds :: TyCon -> RdrNameMonoBinds gen_Enum_binds tycon - = to_enum `AndMonoBinds` + = succ_enum `AndMonoBinds` + pred_enum `AndMonoBinds` + to_enum `AndMonoBinds` enum_from `AndMonoBinds` enum_from_then `AndMonoBinds` from_enum where tycon_loc = getSrcLoc tycon + occ_nm = getOccString tycon + + succ_enum + = mk_easy_FunMonoBind tycon_loc succ_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + HsIf (HsApp (HsApp (HsVar eq_RDR) + (HsVar (maxtag_RDR tycon))) + (mk_easy_App mkInt_RDR [ah_RDR])) + (illegal_Expr "succ" occ_nm "tried to take `succ' of last tag in enumeration") + (HsApp (HsVar (tag2con_RDR tycon)) + (HsApp (HsApp (HsVar plus_RDR) + (mk_easy_App mkInt_RDR [ah_RDR])) + (HsLit (HsInt 1)))) + tycon_loc + + pred_enum + = mk_easy_FunMonoBind tycon_loc pred_RDR [a_Pat] [] $ + untag_Expr tycon [(a_RDR, ah_RDR)] $ + HsIf (HsApp (HsApp (HsVar eq_RDR) (HsLit (HsInt 0))) + (mk_easy_App mkInt_RDR [ah_RDR])) + (illegal_Expr "pred" occ_nm "tried to take `pred' of first tag in enumeration") + (HsApp (HsVar (tag2con_RDR tycon)) + (HsApp (HsApp (HsVar plus_RDR) + (mk_easy_App mkInt_RDR [ah_RDR])) + (HsLit (HsInt (-1))))) + tycon_loc to_enum = mk_easy_FunMonoBind tycon_loc toEnum_RDR [a_Pat] [] $ - mk_easy_App (tag2con_RDR tycon) [a_RDR] + HsIf (HsApp (HsApp + (HsVar and_RDR) + (HsApp (HsApp (HsVar ge_RDR) + (HsVar a_RDR)) + (HsLit (HsInt 0)))) + (HsApp (HsApp (HsVar le_RDR) + (HsVar a_RDR)) + (HsVar (maxtag_RDR tycon)))) + (mk_easy_App (tag2con_RDR tycon) [a_RDR]) + (illegal_toEnum_tag occ_nm (maxtag_RDR tycon)) + tycon_loc enum_from = mk_easy_FunMonoBind tycon_loc enumFrom_RDR [a_Pat] [] $ @@ -433,7 +523,12 @@ gen_Enum_binds 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))) + (HsIf (HsApp (HsApp (HsVar gt_RDR) + (mk_easy_App mkInt_RDR [ah_RDR])) + (mk_easy_App mkInt_RDR [bh_RDR])) + (HsLit (HsInt 0)) + (HsVar (maxtag_RDR tycon)) + tycon_loc)) from_enum = mk_easy_FunMonoBind tycon_loc fromEnum_RDR [a_Pat] [] $ @@ -443,16 +538,6 @@ gen_Enum_binds tycon %************************************************************************ %* * -\subsubsection{Generating @Eval@ instance declarations} -%* * -%************************************************************************ - -\begin{code} -gen_Eval_binds tycon = EmptyMonoBinds -\end{code} - -%************************************************************************ -%* * \subsubsection{Generating @Bounded@ instance declarations} %* * %************************************************************************ @@ -478,7 +563,7 @@ gen_Bounded_binds tycon data_con_N_RDR = qual_orig_name data_con_N ----- single-constructor-flavored: ------------- - arity = argFieldCount data_con_1 + arity = dataConSourceArity data_con_1 min_bound_1con = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] $ mk_easy_App data_con_1_RDR (nOfThem arity minBound_RDR) @@ -535,7 +620,7 @@ instance ... Ix (Foo ...) where False }}} \end{verbatim} -(modulo suitable case-ification to handle the unboxed tags) +(modulo suitable case-ification to handle the unlifted tags) For a single-constructor type (NB: this includes all tuples), e.g., \begin{verbatim} @@ -560,7 +645,8 @@ gen_Ix_binds tycon enum_index `AndMonoBinds` enum_inRange enum_range - = mk_easy_FunMonoBind tycon_loc range_RDR [TuplePatIn [a_Pat, b_Pat]] [] $ + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePatIn [a_Pat, b_Pat] Boxed] [] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ untag_Expr tycon [(b_RDR, bh_RDR)] $ HsApp (mk_easy_App map_RDR [tag2con_RDR tycon]) $ @@ -569,17 +655,18 @@ gen_Ix_binds tycon (mk_easy_App mkInt_RDR [bh_RDR])) enum_index - = mk_easy_FunMonoBind tycon_loc index_RDR [AsPatIn c_RDR (TuplePatIn [a_Pat, b_Pat]), d_Pat] [] ( + = mk_easy_FunMonoBind tycon_loc index_RDR + [AsPatIn c_RDR (TuplePatIn [a_Pat, wildPat] 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 (mk_easy_App mkInt_RDR [c_RDR]) tycon_loc] + rhs = mk_easy_App mkInt_RDR [c_RDR] in HsCase (genOpApp (HsVar dh_RDR) minusH_RDR (HsVar ah_RDR)) - [PatMatch (VarPatIn c_RDR) - (GRHSMatch (GRHSsAndBindsIn grhs EmptyBinds))] + [mkSimpleMatch [VarPatIn c_RDR] rhs Nothing tycon_loc] tycon_loc )) ) {-else-} ( @@ -588,7 +675,8 @@ gen_Ix_binds tycon tycon_loc) enum_inRange - = mk_easy_FunMonoBind tycon_loc inRange_RDR [TuplePatIn [a_Pat, b_Pat], c_Pat] [] ( + = mk_easy_FunMonoBind tycon_loc inRange_RDR + [TuplePatIn [a_Pat, b_Pat] Boxed, c_Pat] [] ( untag_Expr tycon [(a_RDR, ah_RDR)] ( untag_Expr tycon [(b_RDR, bh_RDR)] ( untag_Expr tycon [(c_RDR, ch_RDR)] ( @@ -607,12 +695,12 @@ gen_Ix_binds tycon data_con = case maybeTyConSingleCon tycon of -- just checking... Nothing -> panic "get_Ix_binds" - Just dc -> if (any isPrimType (dataConRawArgTys dc)) then + Just dc -> if (any isUnLiftedType (dataConOrigArgTys dc)) then error ("ERROR: Can't derive Ix for a single-constructor type with primitive argument types: "++tycon_str) else dc - con_arity = argFieldCount data_con + con_arity = dataConSourceArity data_con data_con_RDR = qual_orig_name data_con as_needed = take con_arity as_RDRs @@ -624,45 +712,56 @@ gen_Ix_binds tycon -------------------------------------------------------------- single_con_range - = mk_easy_FunMonoBind tycon_loc range_RDR [TuplePatIn [con_pat as_needed, con_pat bs_needed]] [] $ + = mk_easy_FunMonoBind tycon_loc range_RDR + [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed] [] $ HsDo ListComp stmts tycon_loc where stmts = zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed ++ - [ReturnStmt con_expr] + [ResultStmt con_expr tycon_loc] mk_qual a b c = BindStmt (VarPatIn c) - (HsApp (HsVar range_RDR) (ExplicitTuple [HsVar a, HsVar b])) + (HsApp (HsVar range_RDR) + (ExplicitTuple [HsVar a, HsVar b] Boxed)) tycon_loc ---------------- single_con_index - = mk_easy_FunMonoBind tycon_loc index_RDR [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] [range_size] ( + = mk_easy_FunMonoBind tycon_loc index_RDR + [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed, + 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) = genOpApp ( - (HsApp (HsApp (HsVar index_RDR) (ExplicitTuple [HsVar l, HsVar u])) (HsVar i)) + (HsApp (HsApp (HsVar index_RDR) + (ExplicitTuple [HsVar l, HsVar u] Boxed)) (HsVar i)) ) plus_RDR ( genOpApp ( - (HsApp (HsVar rangeSize_RDR) (ExplicitTuple [HsVar l, HsVar u])) + (HsApp (HsVar rangeSize_RDR) + (ExplicitTuple [HsVar l, HsVar u] Boxed)) ) times_RDR multiply_by ) range_size - = mk_easy_FunMonoBind tycon_loc rangeSize_RDR [TuplePatIn [a_Pat, b_Pat]] [] ( + = mk_easy_FunMonoBind tycon_loc rangeSize_RDR + [TuplePatIn [a_Pat, b_Pat] Boxed] [] ( genOpApp ( - (HsApp (HsApp (HsVar index_RDR) (ExplicitTuple [a_Expr, b_Expr])) b_Expr) + (HsApp (HsApp (HsVar index_RDR) + (ExplicitTuple [a_Expr, b_Expr] Boxed)) b_Expr) ) plus_RDR (HsLit (HsInt 1))) ------------------ single_con_inRange = mk_easy_FunMonoBind tycon_loc inRange_RDR - [TuplePatIn [con_pat as_needed, con_pat bs_needed], con_pat cs_needed] + [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed, + 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 = HsApp (HsApp (HsVar inRange_RDR) (ExplicitTuple [HsVar a, HsVar b])) (HsVar c) + in_range a b c = HsApp (HsApp (HsVar inRange_RDR) + (ExplicitTuple [HsVar a, HsVar b] Boxed)) + (HsVar c) \end{code} %************************************************************************ @@ -671,12 +770,10 @@ gen_Ix_binds tycon %* * %************************************************************************ -Ignoring all the infix-ery mumbo jumbo (ToDo) - \begin{code} -gen_Read_binds :: TyCon -> RdrNameMonoBinds +gen_Read_binds :: (Name -> Maybe Fixity) -> TyCon -> RdrNameMonoBinds -gen_Read_binds tycon +gen_Read_binds get_fixity tycon = reads_prec `AndMonoBinds` read_list where tycon_loc = getSrcLoc tycon @@ -689,95 +786,139 @@ gen_Read_binds tycon read_con_comprehensions = map read_con (tyConDataCons tycon) in - mk_easy_FunMonoBind tycon_loc readsPrec_RDR [a_Pat, b_Pat] [] ( + mk_easy_FunMonoBind tycon_loc readsPrec_RDR [zz_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_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 - = BindStmt - (TuplePatIn [LitPatIn (HsString data_con_str), d_Pat]) - (HsApp (HsVar lex_RDR) c_Expr) - tycon_loc - - str_qual str res draw_from - = BindStmt - (TuplePatIn [LitPatIn (HsString str), VarPatIn res]) - (HsApp (HsVar lex_RDR) draw_from) - tycon_loc + = HsApp ( + readParen_Expr read_paren_arg $ HsPar $ + HsLam (mk_easy_Match tycon_loc [c_Pat] [] $ + HsDo ListComp stmts tycon_loc) + ) (HsVar b_RDR) + where + data_con_RDR = qual_orig_name data_con + data_con_str = occNameUserString (getOccName data_con) + con_arity = dataConSourceArity 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 + dc_nm = getName data_con + is_infix = isDataSymOcc (getOccName dc_nm) + + as_needed = take con_arity as_RDRs + bs_needed + | is_infix = take (1 + con_arity) bs_RDRs + | lab_fields == 0 = take con_arity bs_RDRs + | otherwise = take (4*lab_fields + 1) bs_RDRs + -- (label, '=' and field)*n, (n-1)*',' + '{' + '}' + + (as1:as2:_) = as_needed + (bs1:bs2:bs3:_) = bs_needed + + con_qual + | not is_infix = + BindStmt + (TuplePatIn [LitPatIn (mkHsString data_con_str), d_Pat] Boxed) + (HsApp (HsVar lex_RDR) c_Expr) + tycon_loc + | otherwise = + BindStmt + (TuplePatIn [LitPatIn (mkHsString data_con_str), VarPatIn bs2] Boxed) + (HsApp (HsVar lex_RDR) (HsVar bs1)) + tycon_loc + + + str_qual str res draw_from = + BindStmt + (TuplePatIn [LitPatIn (mkHsString str), VarPatIn res] Boxed) + (HsApp (HsVar lex_RDR) draw_from) + tycon_loc + + str_qual_paren str res draw_from = + BindStmt + (TuplePatIn [LitPatIn (mkHsString str), VarPatIn res] Boxed) + (HsApp (readParen_Expr true_Expr (HsVar lex_RDR)) draw_from) + tycon_loc - read_label f - = let nm = occNameString (getOccName (fieldLabelName f)) - in - [str_qual nm, str_qual SLIT("=")] + read_label f = [rd_lab, str_qual "="] -- 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 + where + rd_lab + | is_op = str_qual_paren nm + | otherwise = str_qual nm + + occ_nm = getOccName (fieldLabelName f) + is_op = isSymOcc occ_nm + nm = occNameUserString occ_nm + + field_quals + | is_infix = + snd (mapAccumL mk_qual_infix + c_Expr + [ (mk_read_qual lp as1, bs1, bs2) + , (mk_read_qual rp as2, bs3, bs3) + ]) + | lab_fields == 0 = -- common case. + snd (mapAccumL mk_qual + d_Expr + (zipWithEqual "as_needed" + (\ con_field draw_from -> (mk_read_qual 10 con_field, + draw_from)) + as_needed bs_needed)) + | otherwise = + snd $ + mapAccumL mk_qual d_Expr (zipEqual "bs_needed" - ((str_qual (SLIT("{")): + ((str_qual "{": concat ( - intersperse ([str_qual (_CONS_ ',' _NIL_)]) $ + intersperse [str_qual ","] $ zipWithEqual "field_quals" (\ as b -> as ++ [b]) -- The labels (map read_label labels) -- The fields - (map mk_read_qual as_needed))) ++ [str_qual (SLIT("}"))]) + (map (mk_read_qual 10) as_needed))) ++ [str_qual "}"]) 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_qual_infix draw_from (f, str_left, str_left2) = + (HsVar str_left2, -- 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]) - (HsApp (HsApp (HsVar readsPrec_RDR) (HsLit (HsInt 10))) draw_from) - tycon_loc + mk_qual draw_from (f, str_left) = + (HsVar str_left, -- what to draw from down the line... + f str_left draw_from) - result_expr = ExplicitTuple [con_expr, if null bs_needed - then d_Expr - else HsVar (last bs_needed)] + mk_read_qual p con_field res draw_from = + BindStmt + (TuplePatIn [VarPatIn con_field, VarPatIn res] Boxed) + (HsApp (HsApp (HsVar readsPrec_RDR) (HsLit (HsInt p))) draw_from) + tycon_loc - stmts = con_qual:field_quals ++ [ReturnStmt result_expr] - - read_paren_arg - = if nullary_con then -- must be False (parens are surely optional) - false_Expr - else -- parens depend on precedence... - HsPar (genOpApp a_Expr gt_RDR (HsLit (HsInt 9))) - in - HsApp ( - readParen_Expr read_paren_arg $ HsPar $ - HsLam (mk_easy_Match tycon_loc [c_Pat] [] $ - HsDo ListComp stmts tycon_loc) - ) (HsVar b_RDR) + result_expr = ExplicitTuple [con_expr, if null bs_needed + then d_Expr + else HsVar (last bs_needed)] Boxed + + [lp,rp] = getLRPrecs is_infix get_fixity dc_nm + quals + | is_infix = let (h:t) = field_quals in (h:con_qual:t) + | otherwise = con_qual:field_quals + + stmts = quals ++ [ResultStmt result_expr tycon_loc] + + {- + c.f. Figure 18 in Haskell 1.1 report. + -} + paren_prec_limit + | not is_infix = defaultPrecedence + | otherwise = getPrecedence get_fixity dc_nm + + read_paren_arg -- parens depend on precedence... + | nullary_con = false_Expr -- it's optional. + | otherwise = HsPar (genOpApp zz_a_Expr gt_RDR (HsLit (HsInt paren_prec_limit))) \end{code} %************************************************************************ @@ -786,12 +927,10 @@ gen_Read_binds tycon %* * %************************************************************************ -Ignoring all the infix-ery mumbo jumbo (ToDo) - \begin{code} -gen_Show_binds :: TyCon -> RdrNameMonoBinds +gen_Show_binds :: (Name -> Maybe Fixity) -> TyCon -> RdrNameMonoBinds -gen_Show_binds tycon +gen_Show_binds get_fixity tycon = shows_prec `AndMonoBinds` show_list where tycon_loc = getSrcLoc tycon @@ -799,73 +938,144 @@ gen_Show_binds 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)) + 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("{") - - 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 + | nullary_con = -- skip the showParen junk... + ASSERT(null bs_needed) + ([wildPat, con_pat], show_con) + | otherwise = + ([a_Pat, con_pat], + showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt paren_prec_limit)))) + (HsPar (nested_compose_Expr show_thingies))) + where + data_con_RDR = qual_orig_name data_con + con_arity = dataConSourceArity 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 + + dc_nm = getName data_con + dc_occ_nm = getOccName data_con + dc_occ_nm_str = occNameUserString dc_occ_nm + + is_infix = isDataSymOcc dc_occ_nm + + + show_con + | is_infix = mk_showString_app (' ':dc_occ_nm_str) + | otherwise = mk_showString_app (dc_occ_nm_str ++ space_ocurly_maybe) + where + space_ocurly_maybe + | nullary_con = "" + | lab_fields == 0 = " " + | otherwise = "{" + + + show_all con fs@(x:xs) + | is_infix = x:con:xs + | otherwise = + let + ccurly_maybe + | lab_fields > 0 = [mk_showString_app "}"] + | 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("=")) + show_label l = mk_showString_app (the_name ++ "=") + where + occ_nm = getOccName (fieldLabelName l) + -- legal, but rare. + is_op = isSymOcc occ_nm + the_name + | is_op = '(':nm ++ ")" + | otherwise = nm + + nm = occNameUserString occ_nm + + + mk_showString_app str = HsApp (HsVar showString_RDR) + (HsLit (mkHsString str)) - mk_showString_app str = HsApp (HsVar showString_RDR) - (HsLit (HsString str)) + prec_cons = getLRPrecs is_infix get_fixity dc_nm - real_show_thingies = + real_show_thingies + | is_infix = + [ HsApp (HsApp (HsVar showsPrec_RDR) (HsLit (HsInt p))) (HsVar b) + | (p,b) <- zip prec_cons bs_needed ] + | otherwise = [ 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 + 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() is not cool here. + intersperse ([mk_showString_app ","]) $ -- Using SLIT()s containing ,s spells trouble. zipWithEqual "gen_Show_binds" (\ a b -> [a,b]) (map show_label labels) real_show_thingies + {- + c.f. Figure 16 and 17 in Haskell 1.1 report + -} + paren_prec_limit + | not is_infix = defaultPrecedence + 1 + | otherwise = getPrecedence get_fixity dc_nm + 1 - 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} +\begin{code} +getLRPrecs :: Bool -> (Name -> Maybe Fixity) -> Name -> [Integer] +getLRPrecs is_infix get_fixity nm = [lp, rp] + where + {- + Figuring out the fixities of the arguments to a constructor, + cf. Figures 16-18 in Haskell 1.1 report. + -} + (con_left_assoc, con_right_assoc) = isLRAssoc get_fixity nm + paren_con_prec = getPrecedence get_fixity nm + + lp + | not is_infix = defaultPrecedence + 1 + | con_left_assoc = paren_con_prec + | otherwise = paren_con_prec + 1 + + rp + | not is_infix = defaultPrecedence + 1 + | con_right_assoc = paren_con_prec + | otherwise = paren_con_prec + 1 + +defaultPrecedence :: Integer +defaultPrecedence = fromInt maxPrecedence + +getPrecedence :: (Name -> Maybe Fixity) -> Name -> Integer +getPrecedence get_fixity nm + = case get_fixity nm of + Just (Fixity x _) -> fromInt x + other -> defaultPrecedence + +isLRAssoc :: (Name -> Maybe Fixity) -> Name -> (Bool, Bool) +isLRAssoc get_fixity nm = + case get_fixity nm `orElse` defaultFixity of + Fixity _ InfixN -> (False, False) + Fixity _ InfixR -> (False, True) + Fixity _ InfixL -> (True, False) + +isInfixOccName :: String -> Bool +isInfixOccName str = + case str of + (':':_) -> True + _ -> False +\end{code} + + %************************************************************************ %* * \subsection{Generating extra binds (@con2tag@ and @tag2con@)} @@ -877,7 +1087,7 @@ data Foo ... = ... con2tag_Foo :: Foo ... -> Int# tag2con_Foo :: Int -> Foo ... -- easier if Int, not Int# -maxtag_Foo :: Int -- ditto (NB: not unboxed) +maxtag_Foo :: Int -- ditto (NB: not unlifted) \end{verbatim} The `tags' here start at zero, hence the @fIRST_TAG@ (currently one) @@ -894,29 +1104,28 @@ gen_tag_n_con_monobind -> RdrNameMonoBinds gen_tag_n_con_monobind (rdr_name, tycon, GenCon2Tag) + | lots_of_constructors + = mk_FunMonoBind (getSrcLoc tycon) rdr_name + [([VarPatIn a_RDR], HsApp getTag_Expr a_Expr)] + + | otherwise = mk_FunMonoBind (getSrcLoc tycon) rdr_name (map mk_stuff (tyConDataCons tycon)) + where - mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) + lots_of_constructors = tyConFamilySize tycon > mAX_FAMILY_SIZE_FOR_VEC_RETURNS + mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) mk_stuff var - = ASSERT(isDataCon var) - ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))) + = ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))) where - pat = ConPatIn var_RDR (nOfThem (argFieldCount var) WildPatIn) + pat = ConPatIn var_RDR (nOfThem (dataConSourceArity var) WildPatIn) var_RDR = qual_orig_name var 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 -> ([RdrNamePat], RdrNameHsExpr) - - mk_stuff var - = ASSERT(isDataCon var) - ([lit_pat], HsVar var_RDR) - where - lit_pat = ConPatIn mkInt_RDR [LitPatIn (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))] - var_RDR = qual_orig_name var + = mk_FunMonoBind (getSrcLoc tycon) rdr_name + [([ConPatIn mkInt_RDR [VarPatIn a_RDR]], + ExprWithTySig (HsApp tagToEnum_Expr a_Expr) + (HsTyVar (qual_orig_name tycon)))] gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag) = mk_easy_FunMonoBind (getSrcLoc tycon) @@ -956,10 +1165,7 @@ mk_easy_FunMonoBind loc fun pats binds expr = FunMonoBind fun False{-not infix-} [mk_easy_Match loc pats binds expr] loc mk_easy_Match loc pats binds expr - = mk_match loc pats expr (mkbind binds) - where - mkbind [] = EmptyBinds - mkbind bs = MonoBind (foldr1 AndMonoBinds bs) [] recursive + = mk_match loc pats expr (mkMonoBind (andMonoBindList binds) [] Recursive) -- The renamer expects everything in its input to be a -- "recursive" MonoBinds, and it is its job to sort things out -- from there. @@ -975,9 +1181,8 @@ mk_FunMonoBind loc fun pats_and_exprs loc mk_match loc pats expr binds - = foldr PatMatch - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS expr loc] binds)) - (map paren pats) + = Match [] (map paren pats) Nothing + (GRHSs (unguardedRHS expr loc) binds Nothing) where paren p@(VarPatIn _) = p paren other_p = ParPatIn other_p @@ -990,7 +1195,7 @@ mk_easy_App f xs = foldl HsApp (HsVar f) (map HsVar xs) ToDo: Better SrcLocs. \begin{code} -compare_Case, cmp_eq_Expr :: +compare_Case :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr @@ -1006,29 +1211,25 @@ careful_compare_Case :: -- checks for primitive types... -> RdrNameHsExpr compare_Case = compare_gen_Case compare_RDR -cmp_eq_Expr = compare_gen_Case cmp_eq_RDR +cmp_eq_Expr a b = HsApp (HsApp (HsVar cmp_eq_RDR) a) b + -- Was: 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 [OtherwiseGRHS lt mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn eqTag_RDR []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS eq mkGeneratedSrcLoc] EmptyBinds)), - - PatMatch (ConPatIn gtTag_RDR []) - (GRHSMatch (GRHSsAndBindsIn [OtherwiseGRHS gt mkGeneratedSrcLoc] EmptyBinds))] - mkGeneratedSrcLoc + [mkSimpleMatch [ConPatIn ltTag_RDR []] lt Nothing generatedSrcLoc, + mkSimpleMatch [ConPatIn eqTag_RDR []] eq Nothing generatedSrcLoc, + mkSimpleMatch [ConPatIn gtTag_RDR []] gt Nothing generatedSrcLoc] + generatedSrcLoc careful_compare_Case ty lt eq gt a b - = if not (isPrimType ty) then + = if not (isUnLiftedType ty) then compare_gen_Case compare_RDR lt eq gt a b else -- we have to do something special for primitive things... HsIf (genOpApp a relevant_eq_op b) eq - (HsIf (genOpApp a relevant_lt_op b) lt gt mkGeneratedSrcLoc) - mkGeneratedSrcLoc + (HsIf (genOpApp a relevant_lt_op b) lt gt generatedSrcLoc) + generatedSrcLoc where relevant_eq_op = assoc_ty_id eq_op_tbl ty relevant_lt_op = assoc_ty_id lt_op_tbl ty @@ -1037,7 +1238,7 @@ assoc_ty_id tyids ty = if null res then panic "assoc_ty" else head res where - res = [id | (ty',id) <- tyids, eqTy ty ty'] + res = [id | (ty',id) <- tyids, ty == ty'] eq_op_tbl = [(charPrimTy, eqH_Char_RDR) @@ -1068,7 +1269,7 @@ append_Expr a b = genOpApp a append_RDR b eq_Expr :: Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr eq_Expr ty a b - = if not (isPrimType ty) then + = if not (isUnLiftedType ty) then genOpApp a eq_RDR b else -- we have to do something special for primitive things... genOpApp a relevant_eq_op b @@ -1077,20 +1278,12 @@ eq_Expr ty a b \end{code} \begin{code} -argFieldCount :: Id -> Int -- Works on data and newtype constructors -argFieldCount con = length (dataConRawArgTys con) -\end{code} - -\begin{code} untag_Expr :: TyCon -> [(RdrName, RdrName)] -> RdrNameHsExpr -> RdrNameHsExpr untag_Expr tycon [] expr = expr untag_Expr tycon ((untag_this, put_tag_here) : more) expr = 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] + [mkSimpleMatch [VarPatIn put_tag_here] (untag_Expr tycon more expr) Nothing generatedSrcLoc] + generatedSrcLoc cmp_tags_Expr :: RdrName -- Comparison op -> RdrName -> RdrName -- Things to compare @@ -1099,7 +1292,7 @@ cmp_tags_Expr :: RdrName -- Comparison op -> RdrNameHsExpr cmp_tags_Expr op a b true_case false_case - = HsIf (genOpApp (HsVar a) op (HsVar b)) true_case false_case mkGeneratedSrcLoc + = HsIf (genOpApp (HsVar a) op (HsVar b)) true_case false_case generatedSrcLoc enum_from_to_Expr :: RdrNameHsExpr -> RdrNameHsExpr @@ -1128,6 +1321,30 @@ nested_compose_Expr (e:es) -- 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"))) +-- illegal_Expr is used when signalling error conditions in the RHS of a derived +-- method. It is currently only used by Enum.{succ,pred} +illegal_Expr meth tp msg = + HsApp (HsVar error_RDR) (HsLit (HsString (_PK_ (meth ++ '{':tp ++ "}: " ++ msg)))) + +-- illegal_toEnum_tag is an extended version of illegal_Expr, which also allows you +-- to include the value of a_RDR in the error string. +illegal_toEnum_tag tp maxtag = + HsApp (HsVar error_RDR) + (HsApp (HsApp (HsVar append_RDR) + (HsLit (HsString (_PK_ ("toEnum{" ++ tp ++ "}: tag ("))))) + (HsApp (HsApp (HsApp + (HsVar showsPrec_RDR) + (HsLit (HsInt 0))) + (HsVar a_RDR)) + (HsApp (HsApp + (HsVar append_RDR) + (HsLit (HsString (_PK_ ") is outside of enumeration's range (0,")))) + (HsApp (HsApp (HsApp + (HsVar showsPrec_RDR) + (HsLit (HsInt 0))) + (HsVar maxtag)) + (HsLit (HsString (_PK_ ")"))))))) + parenify e@(HsVar _) = e parenify e = HsPar e @@ -1136,12 +1353,14 @@ parenify e = HsPar e -- 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 +genOpApp e1 op e2 = mkHsOpApp e1 op e2 \end{code} \begin{code} -qual_orig_name n = case modAndOcc n of { (m,n) -> Qual m n HiFile } +qual_orig_name n = nameRdrName (getName n) +varUnqual n = mkUnqual varName n +zz_a_RDR = varUnqual SLIT("_a") a_RDR = varUnqual SLIT("a") b_RDR = varUnqual SLIT("b") c_RDR = varUnqual SLIT("c") @@ -1157,6 +1376,9 @@ 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) .. ] ] +mkHsString s = HsString (_PK_ s) + +zz_a_Expr = HsVar zz_a_RDR a_Expr = HsVar a_RDR b_Expr = HsVar b_RDR c_Expr = HsVar c_RDR @@ -1167,8 +1389,12 @@ gtTag_Expr = HsVar gtTag_RDR false_Expr = HsVar false_RDR true_Expr = HsVar true_RDR +getTag_Expr = HsVar getTag_RDR +tagToEnum_Expr = HsVar tagToEnumH_RDR con2tag_Expr tycon = HsVar (con2tag_RDR tycon) +wildPat = WildPatIn +zz_a_Pat = VarPatIn zz_a_RDR a_Pat = VarPatIn a_RDR b_Pat = VarPatIn b_RDR c_Pat = VarPatIn c_RDR @@ -1176,7 +1402,7 @@ 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("#")) +con2tag_RDR tycon = varUnqual (_PK_ ("con2tag_" ++ occNameString (getOccName tycon) ++ "#")) +tag2con_RDR tycon = varUnqual (_PK_ ("tag2con_" ++ occNameString (getOccName tycon) ++ "#")) +maxtag_RDR tycon = varUnqual (_PK_ ("maxtag_" ++ occNameString (getOccName tycon) ++ "#")) \end{code}