X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcGenDeriv.lhs;h=94bb15285001c091c3b129d2a35cfd1a899a34a4;hb=9d7da331989abcd1844e9d03b8d1e4163796fa85;hp=b237ca89e62c3482494ac4d6bc162c2bd925226b;hpb=a7b95beb6077ff7c330e98c3d5b9268f33b21827;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcGenDeriv.lhs b/ghc/compiler/typecheck/TcGenDeriv.lhs index b237ca8..94bb152 100644 --- a/ghc/compiler/typecheck/TcGenDeriv.lhs +++ b/ghc/compiler/typecheck/TcGenDeriv.lhs @@ -17,6 +17,8 @@ module TcGenDeriv ( gen_Ord_binds, gen_Read_binds, gen_Show_binds, + gen_Data_binds, + gen_Typeable_binds, gen_tag_n_con_monobind, con2tag_RDR, tag2con_RDR, maxtag_RDR, @@ -26,45 +28,38 @@ module TcGenDeriv ( #include "HsVersions.h" -import HsSyn ( InPat(..), HsExpr(..), MonoBinds(..), - Match(..), GRHSs(..), Stmt(..), HsLit(..), - HsBinds(..), HsType(..), HsDoContext(..), - unguardedRHS, mkSimpleMatch, mkMonoBind, andMonoBindList, placeHolderType - ) -import RdrHsSyn ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat ) -import RdrName ( RdrName, mkUnqual ) -import BasicTypes ( RecFlag(..), Fixity(..), FixityDirection(..) - , maxPrecedence - , Boxity(..) - ) -import FieldLabel ( FieldLabel, fieldLabelName ) -import DataCon ( isNullaryDataCon, dataConTag, +import HsSyn +import RdrName ( RdrName, mkVarUnqual, getRdrName, mkRdrUnqual, + mkDerivedRdrName ) +import BasicTypes ( Fixity(..), maxPrecedence, Boxity(..) ) +import DataCon ( isNullarySrcDataCon, dataConTag, dataConOrigArgTys, dataConSourceArity, fIRST_TAG, - DataCon, + DataCon, dataConName, dataConIsInfix, dataConFieldLabels ) -import Name ( getOccString, getOccName, getSrcLoc, occNameString, - occNameUserString, nameRdrName, varName, - Name, NamedThing(..), - isDataSymOcc, isSymOcc - ) +import Name ( getOccString, getSrcLoc, Name, NamedThing(..) ) import HscTypes ( FixityEnv, lookupFixity ) -import PrelInfo -- Lots of RdrNames -import SrcLoc ( generatedSrcLoc, SrcLoc ) -import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, - maybeTyConSingleCon, tyConFamilySize +import PrelInfo +import PrelNames +import MkId ( eRROR_ID ) +import PrimOp ( PrimOp(..) ) +import SrcLoc ( Located(..), noLoc, srcLocSpan ) +import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon, tyConArity, + maybeTyConSingleCon, tyConFamilySize, tyConTyVars, tyConName ) import TcType ( isUnLiftedType, tcEqType, Type ) -import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, - floatPrimTy, doublePrimTy - ) -import Util ( mapAccumL, zipEqual, zipWithEqual, isSingleton, - zipWith3Equal, nOfThem ) -import Panic ( panic, assertPanic ) -import Maybes ( maybeToBool ) -import Char ( ord ) +import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy, floatPrimTy, doublePrimTy, + intPrimTyCon ) +import TysWiredIn ( charDataCon, intDataCon, floatDataCon, doubleDataCon, + intDataCon_RDR, true_RDR, false_RDR ) +import Util ( zipWithEqual, isSingleton, + zipWith3Equal, nOfThem, zipEqual ) import Constants import List ( partition, intersperse ) +import Outputable +import FastString +import OccName +import Bag \end{code} %************************************************************************ @@ -147,55 +142,41 @@ instance ... Eq (Foo ...) where \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 +gen_Eq_binds :: TyCon -> LHsBinds RdrName gen_Eq_binds tycon = let - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan tycon + (nullary_cons, nonnullary_cons) | isNewTyCon tycon = ([], tyConDataCons tycon) - | otherwise = partition isNullaryDataCon (tyConDataCons tycon) + | otherwise = partition isNullarySrcDataCon (tyConDataCons tycon) rest = if (null nullary_cons) then case maybeTyConSingleCon tycon of Just _ -> [] Nothing -> -- if cons don't match, then False - [([wildPat, wildPat], false_Expr)] + [([nlWildPat, nlWildPat], false_Expr)] else -- calc. and compare the tags [([a_Pat, b_Pat], untag_Expr tycon [(a_RDR,ah_RDR), (b_RDR,bh_RDR)] - (genOpApp (HsVar ah_RDR) eqH_Int_RDR (HsVar bh_RDR)))] + (genOpApp (nlHsVar ah_RDR) eqInt_RDR (nlHsVar bh_RDR)))] in - 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 (mkHsVarApps eq_RDR [a_RDR, b_RDR]))) + listToBag [ + mk_FunBind tycon_loc eq_RDR ((map pats_etc nonnullary_cons) ++ rest), + mk_easy_FunBind tycon_loc ne_RDR [a_Pat, b_Pat] ( + nlHsApp (nlHsVar not_RDR) (nlHsPar (nlHsVarApps eq_RDR [a_RDR, b_RDR]))) + ] where ------------------------------------------------------------------ pats_etc data_con = let - con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed) + con1_pat = nlConVarPat data_con_RDR as_needed + con2_pat = nlConVarPat data_con_RDR bs_needed - data_con_RDR = qual_orig_name data_con + data_con_RDR = getRdrName data_con con_arity = length tys_needed as_needed = take con_arity as_RDRs bs_needed = take con_arity bs_RDRs @@ -207,7 +188,7 @@ gen_Eq_binds tycon 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)) + nested_eq ty a b = nlHsPar (eq_Expr tycon ty (nlHsVar a) (nlHsVar b)) \end{code} %************************************************************************ @@ -307,84 +288,71 @@ If there is only one constructor in the Data Type we don't need the WildCard Pat JJQC-30-Nov-1997 \begin{code} -gen_Ord_binds :: TyCon -> RdrNameMonoBinds +gen_Ord_binds :: TyCon -> LHsBinds RdrName gen_Ord_binds tycon - = compare -- `AndMonoBinds` compare + = unitBag compare -- `AndMonoBinds` compare -- The default declaration in PrelBase handles this where - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan tycon -------------------------------------------------------------------- - compare = mk_easy_FunMonoBind tycon_loc compare_RDR - [a_Pat, b_Pat] - [cmp_eq] - (if maybeToBool (maybeTyConSingleCon tycon) then - --- 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 - -- True case; they are equal - -- If an enumeration type we are done; else - -- recursively compare their components - (if isEnumerationTyCon tycon then - eqTag_Expr - else --- cmp_eq_Expr ltTag_Expr eqTag_Expr gtTag_Expr a_Expr b_Expr --- Ditto - cmp_eq_Expr a_Expr b_Expr - ) + + compare = L tycon_loc (FunBind (L tycon_loc compare_RDR) False compare_matches placeHolderNames) + compare_matches = mkMatchGroup [mkMatch [a_Pat, b_Pat] compare_rhs cmp_eq_binds] + cmp_eq_binds = HsValBinds (ValBindsIn (unitBag cmp_eq) []) + + compare_rhs + | single_con_type = cmp_eq_Expr a_Expr b_Expr + | otherwise + = untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] + (cmp_tags_Expr eqInt_RDR ah_RDR bh_RDR + (cmp_eq_Expr a_Expr b_Expr) -- True case -- 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))) + (cmp_tags_Expr ltInt_RDR ah_RDR bh_RDR ltTag_Expr gtTag_Expr)) tycon_data_cons = tyConDataCons tycon + single_con_type = isSingleton tycon_data_cons (nullary_cons, nonnullary_cons) | isNewTyCon tycon = ([], tyConDataCons tycon) - | otherwise = partition isNullaryDataCon tycon_data_cons - - cmp_eq = - mk_FunMonoBind tycon_loc - cmp_eq_RDR - (if null nonnullary_cons && isSingleton nullary_cons 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 isSingleton tycon_data_cons then - [] - else - [([WildPatIn, WildPatIn], default_rhs)])) + | otherwise = partition isNullarySrcDataCon tycon_data_cons + + cmp_eq = mk_FunBind tycon_loc cmp_eq_RDR cmp_eq_match + cmp_eq_match + | isEnumerationTyCon tycon + -- We know the tags are equal, so if it's an enumeration TyCon, + -- then there is nothing left to do + -- Catch this specially to avoid warnings + -- about overlapping patterns from the desugarer, + -- and to avoid unnecessary pattern-matching + = [([nlWildPat,nlWildPat], eqTag_Expr)] + | otherwise + = map pats_etc nonnullary_cons ++ + (if single_con_type then -- Omit wildcards when there's just one + [] -- constructor, to silence desugarer + else + [([nlWildPat, nlWildPat], default_rhs)]) + where pats_etc data_con = ([con1_pat, con2_pat], nested_compare_expr tys_needed as_needed bs_needed) where - con1_pat = ConPatIn data_con_RDR (map VarPatIn as_needed) - con2_pat = ConPatIn data_con_RDR (map VarPatIn bs_needed) + con1_pat = nlConVarPat data_con_RDR as_needed + con2_pat = nlConVarPat data_con_RDR bs_needed - data_con_RDR = qual_orig_name data_con + data_con_RDR = getRdrName data_con con_arity = length tys_needed as_needed = take con_arity as_RDRs bs_needed = take con_arity bs_RDRs 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) + = careful_compare_Case tycon ty eqTag_Expr (nlHsVar a) (nlHsVar 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) + in careful_compare_Case tycon ty eq_expr (nlHsVar a) (nlHsVar b) default_rhs | null nullary_cons = impossible_Expr -- Keep desugarer from complaining about -- inexhaustive patterns @@ -434,76 +402,75 @@ instance ... Enum (Foo ...) where For @enumFromTo@ and @enumFromThenTo@, we use the default methods. \begin{code} -gen_Enum_binds :: TyCon -> RdrNameMonoBinds +gen_Enum_binds :: TyCon -> LHsBinds RdrName gen_Enum_binds tycon - = succ_enum `AndMonoBinds` - pred_enum `AndMonoBinds` - to_enum `AndMonoBinds` - enum_from `AndMonoBinds` - enum_from_then `AndMonoBinds` - from_enum + = listToBag [ + succ_enum, + pred_enum, + to_enum, + enum_from, + enum_from_then, + from_enum + ] where - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan tycon occ_nm = getOccString tycon succ_enum - = mk_easy_FunMonoBind tycon_loc succ_RDR [a_Pat] [] $ + = mk_easy_FunBind tycon_loc succ_RDR [a_Pat] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ - HsIf (mkHsApps eq_RDR [HsVar (maxtag_RDR tycon), - mkHsVarApps mkInt_RDR [ah_RDR]]) + nlHsIf (nlHsApps eq_RDR [nlHsVar (maxtag_RDR tycon), + nlHsVarApps intDataCon_RDR [ah_RDR]]) (illegal_Expr "succ" occ_nm "tried to take `succ' of last tag in enumeration") - (HsApp (HsVar (tag2con_RDR tycon)) - (mkHsApps plus_RDR [mkHsVarApps mkInt_RDR [ah_RDR], - mkHsIntLit 1])) - tycon_loc + (nlHsApp (nlHsVar (tag2con_RDR tycon)) + (nlHsApps plus_RDR [nlHsVarApps intDataCon_RDR [ah_RDR], + nlHsIntLit 1])) pred_enum - = mk_easy_FunMonoBind tycon_loc pred_RDR [a_Pat] [] $ + = mk_easy_FunBind tycon_loc pred_RDR [a_Pat] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ - HsIf (mkHsApps eq_RDR [mkHsIntLit 0, - mkHsVarApps mkInt_RDR [ah_RDR]]) + nlHsIf (nlHsApps eq_RDR [nlHsIntLit 0, + nlHsVarApps intDataCon_RDR [ah_RDR]]) (illegal_Expr "pred" occ_nm "tried to take `pred' of first tag in enumeration") - (HsApp (HsVar (tag2con_RDR tycon)) - (mkHsApps plus_RDR [mkHsVarApps mkInt_RDR [ah_RDR], - HsLit (HsInt (-1))])) - tycon_loc + (nlHsApp (nlHsVar (tag2con_RDR tycon)) + (nlHsApps plus_RDR [nlHsVarApps intDataCon_RDR [ah_RDR], + nlHsLit (HsInt (-1))])) to_enum - = mk_easy_FunMonoBind tycon_loc toEnum_RDR [a_Pat] [] $ - HsIf (mkHsApps and_RDR - [mkHsApps ge_RDR [HsVar a_RDR, mkHsIntLit 0], - mkHsApps le_RDR [HsVar a_RDR, HsVar (maxtag_RDR tycon)]]) - (mkHsVarApps (tag2con_RDR tycon) [a_RDR]) + = mk_easy_FunBind tycon_loc toEnum_RDR [a_Pat] $ + nlHsIf (nlHsApps and_RDR + [nlHsApps ge_RDR [nlHsVar a_RDR, nlHsIntLit 0], + nlHsApps le_RDR [nlHsVar a_RDR, nlHsVar (maxtag_RDR tycon)]]) + (nlHsVarApps (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] [] $ + = mk_easy_FunBind tycon_loc enumFrom_RDR [a_Pat] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ - mkHsApps map_RDR - [HsVar (tag2con_RDR tycon), - HsPar (enum_from_to_Expr - (mkHsVarApps mkInt_RDR [ah_RDR]) - (HsVar (maxtag_RDR tycon)))] + nlHsApps map_RDR + [nlHsVar (tag2con_RDR tycon), + nlHsPar (enum_from_to_Expr + (nlHsVarApps intDataCon_RDR [ah_RDR]) + (nlHsVar (maxtag_RDR tycon)))] enum_from_then - = mk_easy_FunMonoBind tycon_loc enumFromThen_RDR [a_Pat, b_Pat] [] $ + = mk_easy_FunBind tycon_loc enumFromThen_RDR [a_Pat, b_Pat] $ untag_Expr tycon [(a_RDR, ah_RDR), (b_RDR, bh_RDR)] $ - HsApp (mkHsVarApps map_RDR [tag2con_RDR tycon]) $ - HsPar (enum_from_then_to_Expr - (mkHsVarApps mkInt_RDR [ah_RDR]) - (mkHsVarApps mkInt_RDR [bh_RDR]) - (HsIf (mkHsApps gt_RDR [mkHsVarApps mkInt_RDR [ah_RDR], - mkHsVarApps mkInt_RDR [bh_RDR]]) - (mkHsIntLit 0) - (HsVar (maxtag_RDR tycon)) - tycon_loc)) + nlHsApp (nlHsVarApps map_RDR [tag2con_RDR tycon]) $ + nlHsPar (enum_from_then_to_Expr + (nlHsVarApps intDataCon_RDR [ah_RDR]) + (nlHsVarApps intDataCon_RDR [bh_RDR]) + (nlHsIf (nlHsApps gt_RDR [nlHsVarApps intDataCon_RDR [ah_RDR], + nlHsVarApps intDataCon_RDR [bh_RDR]]) + (nlHsIntLit 0) + (nlHsVar (maxtag_RDR tycon)) + )) from_enum - = mk_easy_FunMonoBind tycon_loc fromEnum_RDR [a_Pat] [] $ + = mk_easy_FunBind tycon_loc fromEnum_RDR [a_Pat] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ - (mkHsVarApps mkInt_RDR [ah_RDR]) + (nlHsVarApps intDataCon_RDR [ah_RDR]) \end{code} %************************************************************************ @@ -515,30 +482,30 @@ gen_Enum_binds tycon \begin{code} gen_Bounded_binds tycon = if isEnumerationTyCon tycon then - min_bound_enum `AndMonoBinds` max_bound_enum + listToBag [ min_bound_enum, max_bound_enum ] else ASSERT(isSingleton data_cons) - min_bound_1con `AndMonoBinds` max_bound_1con + listToBag [ min_bound_1con, max_bound_1con ] where data_cons = tyConDataCons tycon - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan 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) + min_bound_enum = mkVarBind tycon_loc minBound_RDR (nlHsVar data_con_1_RDR) + max_bound_enum = mkVarBind tycon_loc maxBound_RDR (nlHsVar 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 + data_con_1_RDR = getRdrName data_con_1 + data_con_N_RDR = getRdrName data_con_N ----- single-constructor-flavored: ------------- arity = dataConSourceArity data_con_1 - min_bound_1con = mk_easy_FunMonoBind tycon_loc minBound_RDR [] [] $ - mkHsVarApps data_con_1_RDR (nOfThem arity minBound_RDR) - max_bound_1con = mk_easy_FunMonoBind tycon_loc maxBound_RDR [] [] $ - mkHsVarApps data_con_1_RDR (nOfThem arity maxBound_RDR) + min_bound_1con = mkVarBind tycon_loc minBound_RDR $ + nlHsVarApps data_con_1_RDR (nOfThem arity minBound_RDR) + max_bound_1con = mkVarBind tycon_loc maxBound_RDR $ + nlHsVarApps data_con_1_RDR (nOfThem arity maxBound_RDR) \end{code} %************************************************************************ @@ -567,11 +534,11 @@ instance ... Ix (Foo ...) where map tag2con_Foo (enumFromTo (I# a#) (I# b#)) }} - index c@(a, b) d - = if inRange c d - then case (con2tag_Foo d -# con2tag_Foo a) of + -- Generate code for unsafeIndex, becuase using index leads + -- to lots of redundant range tests + unsafeIndex c@(a, b) d + = case (con2tag_Foo d -# con2tag_Foo a) of r# -> I# r# - else error "Ix.Foo.index: out of range" inRange (a, b) c = let @@ -600,137 +567,118 @@ we follow the scheme given in Figure~19 of the Haskell~1.2 report (p.~147). \begin{code} -gen_Ix_binds :: TyCon -> RdrNameMonoBinds +gen_Ix_binds :: TyCon -> LHsBinds RdrName gen_Ix_binds tycon = if isEnumerationTyCon tycon then enum_ixes else single_con_ixes where - tycon_str = getOccString tycon - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan tycon -------------------------------------------------------------- - enum_ixes = enum_range `AndMonoBinds` - enum_index `AndMonoBinds` enum_inRange + enum_ixes = listToBag [ enum_range, enum_index, enum_inRange ] enum_range - = mk_easy_FunMonoBind tycon_loc range_RDR - [TuplePatIn [a_Pat, b_Pat] Boxed] [] $ + = mk_easy_FunBind tycon_loc range_RDR [nlTuplePat [a_Pat, b_Pat] Boxed] $ untag_Expr tycon [(a_RDR, ah_RDR)] $ untag_Expr tycon [(b_RDR, bh_RDR)] $ - HsApp (mkHsVarApps map_RDR [tag2con_RDR tycon]) $ - HsPar (enum_from_to_Expr - (mkHsVarApps mkInt_RDR [ah_RDR]) - (mkHsVarApps mkInt_RDR [bh_RDR])) + nlHsApp (nlHsVarApps map_RDR [tag2con_RDR tycon]) $ + nlHsPar (enum_from_to_Expr + (nlHsVarApps intDataCon_RDR [ah_RDR]) + (nlHsVarApps intDataCon_RDR [bh_RDR])) enum_index - = mk_easy_FunMonoBind tycon_loc index_RDR - [AsPatIn c_RDR (TuplePatIn [a_Pat, wildPat] Boxed), - d_Pat] [] ( - HsIf (HsPar (mkHsVarApps inRange_RDR [c_RDR, d_RDR])) ( + = mk_easy_FunBind tycon_loc unsafeIndex_RDR + [noLoc (AsPat (noLoc c_RDR) + (nlTuplePat [a_Pat, nlWildPat] Boxed)), + d_Pat] ( untag_Expr tycon [(a_RDR, ah_RDR)] ( untag_Expr tycon [(d_RDR, dh_RDR)] ( let - rhs = mkHsVarApps mkInt_RDR [c_RDR] + rhs = nlHsVarApps intDataCon_RDR [c_RDR] in - HsCase - (genOpApp (HsVar dh_RDR) minusH_RDR (HsVar ah_RDR)) - [mkSimpleMatch [VarPatIn c_RDR] rhs placeHolderType tycon_loc] - tycon_loc + nlHsCase + (genOpApp (nlHsVar dh_RDR) minusInt_RDR (nlHsVar ah_RDR)) + [mkSimpleHsAlt (nlVarPat c_RDR) rhs] )) - ) {-else-} ( - HsApp (HsVar error_RDR) (HsLit (HsString (_PK_ ("Ix."++tycon_str++".index: out of range\n")))) ) - tycon_loc) enum_inRange - = mk_easy_FunMonoBind tycon_loc inRange_RDR - [TuplePatIn [a_Pat, b_Pat] Boxed, c_Pat] [] ( + = mk_easy_FunBind tycon_loc inRange_RDR [nlTuplePat [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)] ( - HsIf (genOpApp (HsVar ch_RDR) geH_RDR (HsVar ah_RDR)) ( - (genOpApp (HsVar ch_RDR) leH_RDR (HsVar bh_RDR)) + nlHsIf (genOpApp (nlHsVar ch_RDR) geInt_RDR (nlHsVar ah_RDR)) ( + (genOpApp (nlHsVar ch_RDR) leInt_RDR (nlHsVar bh_RDR)) ) {-else-} ( false_Expr - ) tycon_loc)))) + )))) -------------------------------------------------------------- single_con_ixes - = single_con_range `AndMonoBinds` - single_con_index `AndMonoBinds` - single_con_inRange + = listToBag [single_con_range, single_con_index, single_con_inRange] data_con = case maybeTyConSingleCon tycon of -- just checking... Nothing -> panic "get_Ix_binds" - 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 + Just dc | any isUnLiftedType (dataConOrigArgTys dc) + -> pprPanic "Can't derive Ix for a single-constructor type with primitive argument types:" (ppr tycon) + | otherwise -> dc con_arity = dataConSourceArity data_con - data_con_RDR = qual_orig_name data_con + data_con_RDR = getRdrName data_con as_needed = take con_arity as_RDRs bs_needed = take con_arity bs_RDRs cs_needed = take con_arity cs_RDRs - con_pat xs = ConPatIn data_con_RDR (map VarPatIn xs) - con_expr = mkHsVarApps data_con_RDR cs_needed + con_pat xs = nlConVarPat data_con_RDR xs + con_expr = nlHsVarApps data_con_RDR cs_needed -------------------------------------------------------------- single_con_range - = mk_easy_FunMonoBind tycon_loc range_RDR - [TuplePatIn [con_pat as_needed, con_pat bs_needed] Boxed] [] $ - HsDo ListComp stmts tycon_loc + = mk_easy_FunBind tycon_loc range_RDR + [nlTuplePat [con_pat as_needed, con_pat bs_needed] Boxed] $ + nlHsDo ListComp stmts con_expr where stmts = zipWith3Equal "single_con_range" mk_qual as_needed bs_needed cs_needed - ++ - [ResultStmt con_expr tycon_loc] - mk_qual a b c = BindStmt (VarPatIn c) - (HsApp (HsVar range_RDR) - (ExplicitTuple [HsVar a, HsVar b] Boxed)) - tycon_loc + mk_qual a b c = noLoc $ mkBindStmt (nlVarPat c) + (nlHsApp (nlHsVar range_RDR) + (nlTuple [nlHsVar a, nlHsVar b] Boxed)) ---------------- single_con_index - = 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 (mkHsIntLit 0) (zip3 as_needed bs_needed cs_needed)) + = mk_easy_FunBind tycon_loc unsafeIndex_RDR + [nlTuplePat [con_pat as_needed, con_pat bs_needed] Boxed, + con_pat cs_needed] + (mk_index (zip3 as_needed bs_needed cs_needed)) where - mk_index multiply_by (l, u, i) + -- index (l1,u1) i1 + rangeSize (l1,u1) * (index (l2,u2) i2 + ...) + mk_index [] = nlHsIntLit 0 + mk_index [(l,u,i)] = mk_one l u i + mk_index ((l,u,i) : rest) = genOpApp ( - (mkHsApps index_RDR [ExplicitTuple [HsVar l, HsVar u] Boxed, - HsVar i]) - ) plus_RDR ( + mk_one l u i + ) plus_RDR ( genOpApp ( - (HsApp (HsVar rangeSize_RDR) - (ExplicitTuple [HsVar l, HsVar u] Boxed)) - ) times_RDR multiply_by + (nlHsApp (nlHsVar unsafeRangeSize_RDR) + (nlTuple [nlHsVar l, nlHsVar u] Boxed)) + ) times_RDR (mk_index rest) ) - - range_size - = mk_easy_FunMonoBind tycon_loc rangeSize_RDR - [TuplePatIn [a_Pat, b_Pat] Boxed] [] ( - genOpApp ( - (mkHsApps index_RDR [ExplicitTuple [a_Expr, b_Expr] Boxed, - b_Expr]) - ) plus_RDR (mkHsIntLit 1)) + mk_one l u i + = nlHsApps unsafeIndex_RDR [nlTuple [nlHsVar l, nlHsVar u] Boxed, nlHsVar i] ------------------ single_con_inRange - = mk_easy_FunMonoBind tycon_loc inRange_RDR - [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)) + = mk_easy_FunBind tycon_loc inRange_RDR + [nlTuplePat [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 = mkHsApps inRange_RDR [ExplicitTuple [HsVar a, HsVar b] Boxed, - HsVar c] + in_range a b c = nlHsApps inRange_RDR [nlTuple [nlHsVar a, nlHsVar b] Boxed, + nlHsVar c] \end{code} %************************************************************************ @@ -749,7 +697,7 @@ Example instance Read T where readPrec = - block + parens ( prec 4 ( do x <- ReadP.step Read.readPrec Symbol "%%" <- Lex.lex @@ -758,11 +706,11 @@ instance Read T where +++ prec appPrec ( do Ident "T1" <- Lex.lex - Single '{' <- Lex.lex + Punc '{' <- Lex.lex Ident "f1" <- Lex.lex - Single '=' <- Lex.lex + Punc '=' <- Lex.lex x <- ReadP.reset Read.readPrec - Single '}' <- Lex.lex + Punc '}' <- Lex.lex return (T1 { f1 = x })) +++ prec appPrec ( @@ -776,24 +724,25 @@ instance Read T where \begin{code} -gen_Read_binds :: FixityEnv -> TyCon -> RdrNameMonoBinds +gen_Read_binds :: FixityEnv -> TyCon -> LHsBinds RdrName gen_Read_binds get_fixity tycon - = read_prec `AndMonoBinds` default_binds + = listToBag [read_prec, default_readlist, default_readlistprec] where ----------------------------------------------------------------------- - default_binds - = mk_easy_FunMonoBind loc readList_RDR [] [] (HsVar readListDefault_RDR) - `AndMonoBinds` - mk_easy_FunMonoBind loc readListPrec_RDR [] [] (HsVar readListPrecDefault_RDR) + default_readlist + = mkVarBind loc readList_RDR (nlHsVar readListDefault_RDR) + + default_readlistprec + = mkVarBind loc readListPrec_RDR (nlHsVar readListPrecDefault_RDR) ----------------------------------------------------------------------- - loc = getSrcLoc tycon + loc = getSrcSpan tycon data_cons = tyConDataCons tycon - (nullary_cons, non_nullary_cons) = partition isNullaryDataCon data_cons + (nullary_cons, non_nullary_cons) = partition isNullarySrcDataCon data_cons - read_prec = mk_easy_FunMonoBind loc readPrec_RDR [] [] - (HsApp (HsVar parens_RDR) read_cons) + read_prec = mkVarBind loc readPrec_RDR + (nlHsApp (nlHsVar parens_RDR) read_cons) read_cons = foldr1 mk_alt (read_nullary_cons ++ read_non_nullary_cons) read_non_nullary_cons = map read_non_nullary_con non_nullary_cons @@ -801,75 +750,89 @@ gen_Read_binds get_fixity tycon read_nullary_cons = case nullary_cons of [] -> [] - [con] -> [HsDo DoExpr [BindStmt (ident_pat (data_con_str con)) lex loc, - result_stmt con []] loc] - _ -> [HsApp (HsVar choose_RDR) - (ExplicitList placeHolderType (map mk_pair nullary_cons))] + [con] -> [nlHsDo DoExpr [bindLex (ident_pat (data_con_str con))] + (result_expr con [])] + _ -> [nlHsApp (nlHsVar choose_RDR) + (nlList (map mk_pair nullary_cons))] - mk_pair con = ExplicitTuple [HsLit (data_con_str con), - HsApp (HsVar returnM_RDR) (HsVar (qual_orig_name con))] - Boxed + mk_pair con = nlTuple [nlHsLit (mkHsString (data_con_str con)), + nlHsApp (nlHsVar returnM_RDR) (nlHsVar (getRdrName con))] + Boxed read_non_nullary_con data_con - = mkHsApps prec_RDR [mkHsIntLit prec, HsDo DoExpr stmts loc] + = nlHsApps prec_RDR [nlHsIntLit prec, nlHsDo DoExpr stmts body] where stmts | is_infix = infix_stmts | length labels > 0 = lbl_stmts | otherwise = prefix_stmts + body = result_expr data_con as_needed + con_str = data_con_str data_con + prefix_stmts -- T a b c - = [BindStmt (ident_pat (data_con_str data_con)) lex loc] - ++ map read_arg as_needed - ++ [result_stmt data_con as_needed] + = [bindLex (ident_pat (wrapOpParens con_str))] + ++ read_args - infix_stmts -- a %% b - = [read_arg a1, - BindStmt (symbol_pat (data_con_str data_con)) lex loc, - read_arg a2, - result_stmt data_con [a1,a2]] + infix_stmts -- a %% b, or a `T` b + = [read_a1] + ++ (if isSym con_str + then [bindLex (symbol_pat con_str)] + else [read_punc "`", bindLex (ident_pat con_str), read_punc "`"]) + ++ [read_a2] lbl_stmts -- T { f1 = a, f2 = b } - = [BindStmt (ident_pat (data_con_str data_con)) lex loc, - read_punc '{'] - ++ concat (intersperse [read_punc ','] field_stmts) - ++ [read_punc '}', result_stmt data_con as_needed] + = [bindLex (ident_pat (wrapOpParens con_str)), + read_punc "{"] + ++ concat (intersperse [read_punc ","] field_stmts) + ++ [read_punc "}"] field_stmts = zipWithEqual "lbl_stmts" read_field labels as_needed con_arity = dataConSourceArity data_con - nullary_con = con_arity == 0 labels = dataConFieldLabels data_con - lab_fields = length labels - dc_nm = getName data_con - is_infix = isDataSymOcc (getOccName dc_nm) + dc_nm = getName data_con + is_infix = dataConIsInfix data_con as_needed = take con_arity as_RDRs - (a1:a2:_) = as_needed - - prec | not is_infix = appPrecedence - | otherwise = getPrecedence get_fixity dc_nm + read_args = zipWithEqual "gen_Read_binds" read_arg as_needed (dataConOrigArgTys data_con) + (read_a1:read_a2:_) = read_args + prec = getPrec is_infix get_fixity dc_nm ------------------------------------------------------------------------ -- Helpers ------------------------------------------------------------------------ mk_alt e1 e2 = genOpApp e1 alt_RDR e2 - result_stmt c as = ResultStmt (HsApp (HsVar returnM_RDR) (con_app c as)) loc - con_app c as = mkHsVarApps (qual_orig_name c) as + bindLex pat = noLoc (mkBindStmt pat (nlHsVar lexP_RDR)) + con_app c as = nlHsVarApps (getRdrName c) as + result_expr c as = nlHsApp (nlHsVar returnM_RDR) (con_app c as) - lex = HsVar lexP_RDR - single_pat c = ConPatIn single_RDR [LitPatIn (mkHsChar c)] -- Single 'x' - ident_pat s = ConPatIn ident_RDR [LitPatIn s] -- Ident "foo" - symbol_pat s = ConPatIn symbol_RDR [LitPatIn s] -- Symbol ">>" + punc_pat s = nlConPat punc_RDR [nlLitPat (mkHsString s)] -- Punc 'c' + ident_pat s = nlConPat ident_RDR [nlLitPat (mkHsString s)] -- Ident "foo" + symbol_pat s = nlConPat symbol_RDR [nlLitPat (mkHsString s)] -- Symbol ">>" - lbl_str :: FieldLabel -> HsLit - lbl_str lbl = mkHsString (occNameUserString (getOccName (fieldLabelName lbl))) - data_con_str con = mkHsString (occNameUserString (getOccName con)) + data_con_str con = occNameString (getOccName con) - read_punc c = BindStmt (single_pat c) lex loc - read_arg a = BindStmt (VarPatIn a) (mkHsVarApps step_RDR [readPrec_RDR]) loc + read_punc c = bindLex (punc_pat c) + read_arg a ty + | isUnLiftedType ty = pprPanic "Error in deriving:" (text "Can't read unlifted types yet:" <+> ppr ty) + | otherwise = noLoc (mkBindStmt (nlVarPat a) (nlHsVarApps step_RDR [readPrec_RDR])) - read_field lbl a = [BindStmt (ident_pat (lbl_str lbl)) lex loc, - read_punc '=', - BindStmt (VarPatIn a) (mkHsVarApps reset_RDR [readPrec_RDR]) loc] + read_field lbl a = read_lbl lbl ++ + [read_punc "=", + noLoc (mkBindStmt (nlVarPat a) (nlHsVarApps reset_RDR [readPrec_RDR]))] + + -- When reading field labels we might encounter + -- a = 3 + -- _a = 3 + -- or (#) = 4 + -- Note the parens! + read_lbl lbl | isSym lbl_str + = [read_punc "(", + bindLex (symbol_pat lbl_str), + read_punc ")"] + | otherwise + = [bindLex (ident_pat lbl_str)] + where + lbl_str = occNameString (getOccName lbl) \end{code} @@ -879,148 +842,314 @@ gen_Read_binds get_fixity tycon %* * %************************************************************************ +Example + + infixr 5 :^: + + data Tree a = Leaf a | Tree a :^: Tree a + + instance (Show a) => Show (Tree a) where + + showsPrec d (Leaf m) = showParen (d > app_prec) showStr + where + showStr = showString "Leaf " . showsPrec (app_prec+1) m + + showsPrec d (u :^: v) = showParen (d > up_prec) showStr + where + showStr = showsPrec (up_prec+1) u . + showString " :^: " . + showsPrec (up_prec+1) v + -- Note: right-associativity of :^: ignored + + up_prec = 5 -- Precedence of :^: + app_prec = 10 -- Application has precedence one more than + -- the most tightly-binding operator + \begin{code} -gen_Show_binds :: FixityEnv -> TyCon -> RdrNameMonoBinds +gen_Show_binds :: FixityEnv -> TyCon -> LHsBinds RdrName gen_Show_binds get_fixity tycon - = shows_prec `AndMonoBinds` show_list + = listToBag [shows_prec, show_list] where - tycon_loc = getSrcLoc tycon + tycon_loc = getSrcSpan tycon ----------------------------------------------------------------------- - show_list = mk_easy_FunMonoBind tycon_loc showList_RDR [] [] - (HsApp (HsVar showList___RDR) (HsPar (HsApp (HsVar showsPrec_RDR) (mkHsIntLit 0)))) + show_list = mkVarBind tycon_loc showList_RDR + (nlHsApp (nlHsVar showList___RDR) (nlHsPar (nlHsApp (nlHsVar showsPrec_RDR) (nlHsIntLit 0)))) ----------------------------------------------------------------------- - shows_prec = mk_FunMonoBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon)) + shows_prec = mk_FunBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon)) where pats_etc data_con | nullary_con = -- skip the showParen junk... ASSERT(null bs_needed) - ([wildPat, con_pat], show_con) + ([nlWildPat, con_pat], mk_showString_app con_str) | otherwise = ([a_Pat, con_pat], - showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt paren_prec_limit)))) - (HsPar (nested_compose_Expr show_thingies))) + showParen_Expr (nlHsPar (genOpApp a_Expr ge_RDR (nlHsLit (HsInt con_prec_plus_one)))) + (nlHsPar (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 + data_con_RDR = getRdrName data_con + con_arity = dataConSourceArity data_con + bs_needed = take con_arity bs_RDRs + arg_tys = dataConOrigArgTys data_con -- Correspond 1-1 with bs_needed + con_pat = nlConVarPat data_con_RDR bs_needed + nullary_con = con_arity == 0 + labels = dataConFieldLabels data_con + lab_fields = length labels + record_syntax = lab_fields > 0 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 + con_str = occNameString dc_occ_nm + op_con_str = wrapOpParens con_str + backquote_str = wrapOpBackquotes con_str + + show_thingies + | is_infix = [show_arg1, mk_showString_app (" " ++ backquote_str ++ " "), show_arg2] + | record_syntax = mk_showString_app (op_con_str ++ " {") : + show_record_args ++ [mk_showString_app "}"] + | otherwise = mk_showString_app (op_con_str ++ " ") : show_prefix_args - show_label l = mk_showString_app (the_name ++ "=") + show_label l = mk_showString_app (nm ++ " = ") + -- Note the spaces around the "=" sign. If we don't have them + -- then we get Foo { x=-1 } and the "=-" parses as a single + -- lexeme. Only the space after the '=' is necessary, but + -- it seems tidier to have them both sides. 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)) - - prec_cons = getLRPrecs is_infix get_fixity dc_nm - - real_show_thingies - | is_infix = - [ mkHsApps showsPrec_RDR [HsLit (HsInt p), HsVar b] - | (p,b) <- zip prec_cons bs_needed ] - | otherwise = - [ mkHsApps showsPrec_RDR [mkHsIntLit 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 ","]) $ -- Using SLIT()s containing ,s spells trouble. - zipWithEqual "gen_Show_binds" - (\ a b -> [a,b]) - (map show_label labels) - real_show_thingies + occ_nm = getOccName l + nm = wrapOpParens (occNameString occ_nm) + + show_args = zipWith show_arg bs_needed arg_tys + (show_arg1:show_arg2:_) = show_args + show_prefix_args = intersperse (nlHsVar showSpace_RDR) show_args + + -- Assumption for record syntax: no of fields == no of labelled fields + -- (and in same order) + show_record_args = concat $ + intersperse [mk_showString_app ", "] $ + [ [show_label lbl, arg] + | (lbl,arg) <- zipEqual "gen_Show_binds" + labels show_args ] - {- - c.f. Figure 16 and 17 in Haskell 1.1 report - -} - paren_prec_limit - | not is_infix = appPrecedence + 1 - | otherwise = getPrecedence get_fixity dc_nm + 1 - + -- Generates (showsPrec p x) for argument x, but it also boxes + -- the argument first if necessary. Note that this prints unboxed + -- things without any '#' decorations; could change that if need be + show_arg b arg_ty = nlHsApps showsPrec_RDR [nlHsLit (HsInt arg_prec), + box_if_necy "Show" tycon (nlHsVar b) arg_ty] + + -- Fixity stuff + is_infix = dataConIsInfix data_con + con_prec_plus_one = 1 + getPrec is_infix get_fixity dc_nm + arg_prec | record_syntax = 0 -- Record fields don't need parens + | otherwise = con_prec_plus_one + +wrapOpParens :: String -> String +wrapOpParens s | isSym s = '(' : s ++ ")" + | otherwise = s + +wrapOpBackquotes :: String -> String +wrapOpBackquotes s | isSym s = s + | otherwise = '`' : s ++ "`" + +isSym :: String -> Bool +isSym "" = False +isSym (c:cs) = startsVarSym c || startsConSym c + +mk_showString_app str = nlHsApp (nlHsVar showString_RDR) (nlHsLit (mkHsString str)) \end{code} \begin{code} -getLRPrecs :: Bool -> FixityEnv -> 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 = appPrecedence + 1 - | con_left_assoc = paren_con_prec - | otherwise = paren_con_prec + 1 - - rp - | not is_infix = appPrecedence + 1 - | con_right_assoc = paren_con_prec - | otherwise = paren_con_prec + 1 +getPrec :: Bool -> FixityEnv -> Name -> Integer +getPrec is_infix get_fixity nm + | not is_infix = appPrecedence + | otherwise = getPrecedence get_fixity nm appPrecedence :: Integer -appPrecedence = fromIntegral maxPrecedence +appPrecedence = fromIntegral maxPrecedence + 1 + -- One more than the precedence of the most + -- tightly-binding operator getPrecedence :: FixityEnv -> Name -> Integer getPrecedence get_fixity nm = case lookupFixity get_fixity nm of Fixity x _ -> fromIntegral x +\end{code} -isLRAssoc :: FixityEnv -> Name -> (Bool, Bool) -isLRAssoc get_fixity nm = - case lookupFixity get_fixity nm of - Fixity _ InfixN -> (False, False) - Fixity _ InfixR -> (False, True) - Fixity _ InfixL -> (True, False) + +%************************************************************************ +%* * +\subsection{Typeable} +%* * +%************************************************************************ + +From the data type + + data T a b = .... + +we generate + + instance Typeable2 T where + typeOf2 _ = mkTyConApp (mkTyConRep "T") [] + +We are passed the Typeable2 class as well as T + +\begin{code} +gen_Typeable_binds :: TyCon -> LHsBinds RdrName +gen_Typeable_binds tycon + = unitBag $ + mk_easy_FunBind tycon_loc + (mk_typeOf_RDR tycon) -- Name of appropriate type0f function + [nlWildPat] + (nlHsApps mkTypeRep_RDR [tycon_rep, nlList []]) + where + tycon_loc = getSrcSpan tycon + tycon_rep = nlHsVar mkTyConRep_RDR `nlHsApp` nlHsLit (mkHsString (showSDoc (ppr tycon))) + +mk_typeOf_RDR :: TyCon -> RdrName +-- Use the arity of the TyCon to make the right typeOfn function +mk_typeOf_RDR tycon = varQual_RDR tYPEABLE (mkFastString ("typeOf" ++ suffix)) + where + arity = tyConArity tycon + suffix | arity == 0 = "" + | otherwise = show arity \end{code} + +%************************************************************************ +%* * +\subsection{Data} +%* * +%************************************************************************ + +From the data type + + data T a b = T1 a b | T2 + +we generate + + $cT1 = mkDataCon $dT "T1" Prefix + $cT2 = mkDataCon $dT "T2" Prefix + $dT = mkDataType "Module.T" [] [$con_T1, $con_T2] + -- the [] is for field labels. + + instance (Data a, Data b) => Data (T a b) where + gfoldl k z (T1 a b) = z T `k` a `k` b + gfoldl k z T2 = z T2 + -- ToDo: add gmapT,Q,M, gfoldr + + gunfold k z c = case conIndex c of + I# 1# -> k (k (z T1)) + I# 2# -> z T2 + + toConstr (T1 _ _) = $cT1 + toConstr T2 = $cT2 + + dataTypeOf _ = $dT + +\begin{code} +gen_Data_binds :: FixityEnv + -> TyCon + -> (LHsBinds RdrName, -- The method bindings + LHsBinds RdrName) -- Auxiliary bindings +gen_Data_binds fix_env tycon + = (listToBag [gfoldl_bind, gunfold_bind, toCon_bind, dataTypeOf_bind], + -- Auxiliary definitions: the data type and constructors + datatype_bind `consBag` listToBag (map mk_con_bind data_cons)) + where + tycon_loc = getSrcSpan tycon + tycon_name = tyConName tycon + data_cons = tyConDataCons tycon + n_cons = length data_cons + one_constr = n_cons == 1 + + ------------ gfoldl + gfoldl_bind = mk_FunBind tycon_loc gfoldl_RDR (map gfoldl_eqn data_cons) + gfoldl_eqn con = ([nlVarPat k_RDR, nlVarPat z_RDR, nlConVarPat con_name as_needed], + foldl mk_k_app (nlHsVar z_RDR `nlHsApp` nlHsVar con_name) as_needed) + where + con_name :: RdrName + con_name = getRdrName con + as_needed = take (dataConSourceArity con) as_RDRs + mk_k_app e v = nlHsPar (nlHsOpApp e k_RDR (nlHsVar v)) + + ------------ gunfold + gunfold_bind = mk_FunBind tycon_loc + gunfold_RDR + [([k_Pat, z_Pat, if one_constr then nlWildPat else c_Pat], + gunfold_rhs)] + + gunfold_rhs + | one_constr = mk_unfold_rhs (head data_cons) -- No need for case + | otherwise = nlHsCase (nlHsVar conIndex_RDR `nlHsApp` c_Expr) + (map gunfold_alt data_cons) + + gunfold_alt dc = mkSimpleHsAlt (mk_unfold_pat dc) (mk_unfold_rhs dc) + mk_unfold_rhs dc = foldr nlHsApp + (nlHsVar z_RDR `nlHsApp` nlHsVar (getRdrName dc)) + (replicate (dataConSourceArity dc) (nlHsVar k_RDR)) + + mk_unfold_pat dc -- Last one is a wild-pat, to avoid + -- redundant test, and annoying warning + | tag-fIRST_TAG == n_cons-1 = nlWildPat -- Last constructor + | otherwise = nlConPat intDataCon_RDR [nlLitPat (HsIntPrim (toInteger tag))] + where + tag = dataConTag dc + + ------------ toConstr + toCon_bind = mk_FunBind tycon_loc toConstr_RDR (map to_con_eqn data_cons) + to_con_eqn dc = ([nlWildConPat dc], nlHsVar (mk_constr_name dc)) + + ------------ dataTypeOf + dataTypeOf_bind = mk_easy_FunBind + tycon_loc + dataTypeOf_RDR + [nlWildPat] + (nlHsVar data_type_name) + + ------------ $dT + + data_type_name = mkDerivedRdrName tycon_name mkDataTOcc + datatype_bind = mkVarBind + tycon_loc + data_type_name + ( nlHsVar mkDataType_RDR + `nlHsApp` nlHsLit (mkHsString (showSDoc (ppr tycon))) + `nlHsApp` nlList constrs + ) + constrs = [nlHsVar (mk_constr_name con) | con <- data_cons] + + + ------------ $cT1 etc + mk_constr_name con = mkDerivedRdrName (dataConName con) mkDataCOcc + mk_con_bind dc = mkVarBind + tycon_loc + (mk_constr_name dc) + (nlHsApps mkConstr_RDR (constr_args dc)) + constr_args dc = + [ -- nlHsIntLit (toInteger (dataConTag dc)), -- Tag + nlHsVar data_type_name, -- DataType + nlHsLit (mkHsString (occNameString dc_occ)), -- String name + nlList labels, -- Field labels + nlHsVar fixity] -- Fixity + where + labels = map (nlHsLit . mkHsString . getOccString) + (dataConFieldLabels dc) + dc_occ = getOccName dc + is_infix = isDataSymOcc dc_occ + fixity | is_infix = infix_RDR + | otherwise = prefix_RDR + +gfoldl_RDR = varQual_RDR gENERICS FSLIT("gfoldl") +gunfold_RDR = varQual_RDR gENERICS FSLIT("gunfold") +toConstr_RDR = varQual_RDR gENERICS FSLIT("toConstr") +dataTypeOf_RDR = varQual_RDR gENERICS FSLIT("dataTypeOf") +mkConstr_RDR = varQual_RDR gENERICS FSLIT("mkConstr") +mkDataType_RDR = varQual_RDR gENERICS FSLIT("mkDataType") +conIndex_RDR = varQual_RDR gENERICS FSLIT("constrIndex") +prefix_RDR = dataQual_RDR gENERICS FSLIT("Prefix") +infix_RDR = dataQual_RDR gENERICS FSLIT("Infix") +\end{code} + %************************************************************************ %* * \subsection{Generating extra binds (@con2tag@ and @tag2con@)} @@ -1043,38 +1172,53 @@ data TagThingWanted = GenCon2Tag | GenTag2Con | GenMaxTag gen_tag_n_con_monobind - :: (RdrName, -- (proto)Name for the thing in question + :: ( RdrName, -- (proto)Name for the thing in question TyCon, -- tycon in question TagThingWanted) - -> RdrNameMonoBinds + -> LHsBind RdrName 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)] + = mk_FunBind tycon_loc rdr_name [([], get_tag_rhs)] | otherwise - = mk_FunMonoBind (getSrcLoc tycon) rdr_name (map mk_stuff (tyConDataCons tycon)) + = mk_FunBind tycon_loc rdr_name (map mk_stuff (tyConDataCons tycon)) where + tycon_loc = getSrcSpan tycon + + tvs = map (mkRdrUnqual . getOccName) (tyConTyVars tycon) + -- We can't use gerRdrName because that makes an Exact RdrName + -- and we can't put them in the LocalRdrEnv + + -- Give a signature to the bound variable, so + -- that the case expression generated by getTag is + -- monomorphic. In the push-enter model we get better code. + get_tag_rhs = noLoc $ ExprWithTySig + (nlHsLam (mkSimpleHsAlt (nlVarPat a_RDR) + (nlHsApp (nlHsVar getTag_RDR) a_Expr))) + (noLoc (mkExplicitHsForAllTy (map (noLoc.UserTyVar) tvs) (noLoc []) con2tag_ty)) + + con2tag_ty = foldl nlHsAppTy (nlHsTyVar (getRdrName tycon)) + (map nlHsTyVar tvs) + `nlHsFunTy` + nlHsTyVar (getRdrName intPrimTyCon) + lots_of_constructors = tyConFamilySize tycon > mAX_FAMILY_SIZE_FOR_VEC_RETURNS - mk_stuff :: DataCon -> ([RdrNamePat], RdrNameHsExpr) - mk_stuff var - = ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG)))) - where - pat = ConPatIn var_RDR (nOfThem (dataConSourceArity var) WildPatIn) - var_RDR = qual_orig_name var + mk_stuff :: DataCon -> ([LPat RdrName], LHsExpr RdrName) + mk_stuff con = ([nlWildConPat con], + nlHsLit (HsIntPrim (toInteger ((dataConTag con) - fIRST_TAG)))) gen_tag_n_con_monobind (rdr_name, tycon, GenTag2Con) - = mk_FunMonoBind (getSrcLoc tycon) rdr_name - [([ConPatIn mkInt_RDR [VarPatIn a_RDR]], - ExprWithTySig (HsApp tagToEnum_Expr a_Expr) - (HsTyVar (qual_orig_name tycon)))] + = mk_FunBind (getSrcSpan tycon) rdr_name + [([nlConVarPat intDataCon_RDR [a_RDR]], + noLoc (ExprWithTySig (nlHsApp (nlHsVar tagToEnum_RDR) a_Expr) + (nlHsTyVar (getRdrName tycon))))] gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag) - = mk_easy_FunMonoBind (getSrcLoc tycon) - rdr_name [] [] (HsApp (HsVar mkInt_RDR) (HsLit (HsIntPrim max_tag))) + = mkVarBind (getSrcSpan tycon) rdr_name + (nlHsApp (nlHsVar intDataCon_RDR) (nlHsLit (HsIntPrim max_tag))) where max_tag = case (tyConDataCons tycon) of data_cons -> toInteger ((length data_cons) - fIRST_TAG) @@ -1087,265 +1231,250 @@ gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag) %* * %************************************************************************ -@mk_easy_FunMonoBind fun pats binds expr@ generates: -\begin{verbatim} - fun pat1 pat2 ... patN = expr where binds -\end{verbatim} - -@mk_FunMonoBind fun [([p1a, p1b, ...], e1), ...]@ is for -multi-clause definitions; it generates: -\begin{verbatim} - fun p1a p1b ... p1N = e1 - fun p2a p2b ... p2N = e2 - ... - fun pMa pMb ... pMN = eM -\end{verbatim} - -\begin{code} -mk_easy_FunMonoBind :: SrcLoc -> RdrName -> [RdrNamePat] - -> [RdrNameMonoBinds] -> RdrNameHsExpr - -> RdrNameMonoBinds - -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 (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. - -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_match loc pats expr binds - = Match (map paren pats) Nothing - (GRHSs (unguardedRHS expr loc) binds placeHolderType) - where - paren p@(VarPatIn _) = p - paren other_p = ParPatIn other_p -\end{code} - -\begin{code} -mkHsApps f xs = foldl HsApp (HsVar f) xs -mkHsVarApps f xs = foldl HsApp (HsVar f) (map HsVar xs) - -mkHsIntLit n = HsLit (HsInt n) -mkHsString s = HsString (_PK_ s) -mkHsChar c = HsChar (ord c) -\end{code} ToDo: Better SrcLocs. \begin{code} compare_gen_Case :: - RdrName - -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr + LHsExpr RdrName -- What to do for equality + -> LHsExpr RdrName -> LHsExpr RdrName + -> LHsExpr RdrName careful_compare_Case :: -- checks for primitive types... - Type - -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr + TyCon -- The tycon we are deriving for + -> Type + -> LHsExpr RdrName -- What to do for equality + -> LHsExpr RdrName -> LHsExpr RdrName + -> LHsExpr RdrName -cmp_eq_Expr a b = HsApp (HsApp (HsVar cmp_eq_RDR) a) b +cmp_eq_Expr a b = nlHsApp (nlHsApp (nlHsVar 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-} - [mkSimpleMatch [ConPatIn ltTag_RDR []] lt placeHolderType generatedSrcLoc, - mkSimpleMatch [ConPatIn eqTag_RDR []] eq placeHolderType generatedSrcLoc, - mkSimpleMatch [ConPatIn gtTag_RDR []] gt placeHolderType generatedSrcLoc] - generatedSrcLoc - -careful_compare_Case ty lt eq gt a b - | not (isUnLiftedType ty) = - compare_gen_Case compare_RDR lt eq gt a b - | otherwise = - -- 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 generatedSrcLoc) - generatedSrcLoc +compare_gen_Case (L _ (HsVar eq_tag)) a b | eq_tag == eqTag_RDR + = nlHsApp (nlHsApp (nlHsVar compare_RDR) a) b -- Simple case +compare_gen_Case eq a b -- General case + = nlHsCase (nlHsPar (nlHsApp (nlHsApp (nlHsVar compare_RDR) a) b)) {-of-} + [mkSimpleHsAlt (nlNullaryConPat ltTag_RDR) ltTag_Expr, + mkSimpleHsAlt (nlNullaryConPat eqTag_RDR) eq, + mkSimpleHsAlt (nlNullaryConPat gtTag_RDR) gtTag_Expr] + +careful_compare_Case tycon ty eq a b + | not (isUnLiftedType ty) + = compare_gen_Case eq a b + | otherwise -- We have to do something special for primitive things... + = nlHsIf (genOpApp a relevant_eq_op b) + eq + (nlHsIf (genOpApp a relevant_lt_op b) ltTag_Expr gtTag_Expr) where - 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 + relevant_eq_op = primOpRdrName (assoc_ty_id "Ord" tycon eq_op_tbl ty) + relevant_lt_op = primOpRdrName (assoc_ty_id "Ord" tycon lt_op_tbl ty) + + +box_if_necy :: String -- The class involved + -> TyCon -- The tycon involved + -> LHsExpr RdrName -- The argument + -> Type -- The argument type + -> LHsExpr RdrName -- Boxed version of the arg +box_if_necy cls_str tycon arg arg_ty + | isUnLiftedType arg_ty = nlHsApp (nlHsVar box_con) arg + | otherwise = arg + where + box_con = assoc_ty_id cls_str tycon box_con_tbl arg_ty + +assoc_ty_id :: String -- The class involved + -> TyCon -- The tycon involved + -> [(Type,a)] -- The table + -> Type -- The type + -> a -- The result of the lookup +assoc_ty_id cls_str tycon tbl ty + | null res = pprPanic "Error in deriving:" (text "Can't derive" <+> text cls_str <+> + text "for primitive type" <+> ppr ty) + | otherwise = head res where - res = [id | (ty',id) <- tyids, ty `tcEqType` ty'] + res = [id | (ty',id) <- tbl, ty `tcEqType` ty'] +eq_op_tbl :: [(Type, PrimOp)] 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) + [(charPrimTy, CharEqOp) + ,(intPrimTy, IntEqOp) + ,(wordPrimTy, WordEqOp) + ,(addrPrimTy, AddrEqOp) + ,(floatPrimTy, FloatEqOp) + ,(doublePrimTy, DoubleEqOp) ] +lt_op_tbl :: [(Type, PrimOp)] 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) + [(charPrimTy, CharLtOp) + ,(intPrimTy, IntLtOp) + ,(wordPrimTy, WordLtOp) + ,(addrPrimTy, AddrLtOp) + ,(floatPrimTy, FloatLtOp) + ,(doublePrimTy, DoubleLtOp) ] ------------------------------------------------------------------------ +box_con_tbl = + [(charPrimTy, getRdrName charDataCon) + ,(intPrimTy, getRdrName intDataCon) + ,(wordPrimTy, wordDataCon_RDR) + ,(addrPrimTy, addrDataCon_RDR) + ,(floatPrimTy, getRdrName floatDataCon) + ,(doublePrimTy, getRdrName doubleDataCon) + ] -and_Expr, append_Expr :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr +----------------------------------------------------------------------- -and_Expr a b = genOpApp a and_RDR b -append_Expr a b = genOpApp a append_RDR b +and_Expr :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName +and_Expr a b = genOpApp a and_RDR b ----------------------------------------------------------------------- -eq_Expr :: Type -> RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr -eq_Expr ty a b = genOpApp a eq_op b +eq_Expr :: TyCon -> Type -> LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName +eq_Expr tycon ty a b = genOpApp a eq_op b where eq_op | not (isUnLiftedType ty) = eq_RDR - | otherwise = + | otherwise = primOpRdrName (assoc_ty_id "Eq" tycon eq_op_tbl ty) -- we have to do something special for primitive things... - assoc_ty_id eq_op_tbl ty - \end{code} \begin{code} -untag_Expr :: TyCon -> [(RdrName, RdrName)] -> RdrNameHsExpr -> RdrNameHsExpr +untag_Expr :: TyCon -> [( RdrName, RdrName)] -> LHsExpr RdrName -> LHsExpr RdrName 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-} - [mkSimpleMatch [VarPatIn put_tag_here] (untag_Expr tycon more expr) placeHolderType generatedSrcLoc] - generatedSrcLoc + = nlHsCase (nlHsPar (nlHsVarApps (con2tag_RDR tycon) [untag_this])) {-of-} + [mkSimpleHsAlt (nlVarPat put_tag_here) (untag_Expr tycon more expr)] -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 :: RdrName -- Comparison op + -> RdrName -> RdrName -- Things to compare + -> LHsExpr RdrName -- What to return if true + -> LHsExpr RdrName -- What to return if false + -> LHsExpr RdrName cmp_tags_Expr op a b true_case false_case - = HsIf (genOpApp (HsVar a) op (HsVar b)) true_case false_case generatedSrcLoc + = nlHsIf (genOpApp (nlHsVar a) op (nlHsVar b)) true_case false_case enum_from_to_Expr - :: RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr + :: LHsExpr RdrName -> LHsExpr RdrName + -> LHsExpr RdrName enum_from_then_to_Expr - :: RdrNameHsExpr -> RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr + :: LHsExpr RdrName -> LHsExpr RdrName -> LHsExpr RdrName + -> LHsExpr RdrName -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 +enum_from_to_Expr f t2 = nlHsApp (nlHsApp (nlHsVar enumFromTo_RDR) f) t2 +enum_from_then_to_Expr f t t2 = nlHsApp (nlHsApp (nlHsApp (nlHsVar enumFromThenTo_RDR) f) t) t2 showParen_Expr - :: RdrNameHsExpr -> RdrNameHsExpr - -> RdrNameHsExpr + :: LHsExpr RdrName -> LHsExpr RdrName + -> LHsExpr RdrName -showParen_Expr e1 e2 = HsApp (HsApp (HsVar showParen_RDR) e1) e2 +showParen_Expr e1 e2 = nlHsApp (nlHsApp (nlHsVar showParen_RDR) e1) e2 -nested_compose_Expr :: [RdrNameHsExpr] -> RdrNameHsExpr +nested_compose_Expr :: [LHsExpr RdrName] -> LHsExpr RdrName nested_compose_Expr [e] = parenify e nested_compose_Expr (e:es) - = HsApp (HsApp (HsVar compose_RDR) (parenify e)) (nested_compose_Expr es) + = nlHsApp (nlHsApp (nlHsVar compose_RDR) (parenify e)) (nested_compose_Expr es) -- 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"))) +impossible_Expr = nlHsApp (nlHsVar error_RDR) (nlHsLit (mkHsString "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)))) + nlHsApp (nlHsVar error_RDR) (nlHsLit (mkHsString (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) - (mkHsIntLit 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) - (mkHsIntLit 0)) - (HsVar maxtag)) - (HsLit (HsString (_PK_ ")"))))))) - -parenify e@(HsVar _) = e -parenify e = HsPar e + nlHsApp (nlHsVar error_RDR) + (nlHsApp (nlHsApp (nlHsVar append_RDR) + (nlHsLit (mkHsString ("toEnum{" ++ tp ++ "}: tag (")))) + (nlHsApp (nlHsApp (nlHsApp + (nlHsVar showsPrec_RDR) + (nlHsIntLit 0)) + (nlHsVar a_RDR)) + (nlHsApp (nlHsApp + (nlHsVar append_RDR) + (nlHsLit (mkHsString ") is outside of enumeration's range (0,"))) + (nlHsApp (nlHsApp (nlHsApp + (nlHsVar showsPrec_RDR) + (nlHsIntLit 0)) + (nlHsVar maxtag)) + (nlHsLit (mkHsString ")")))))) + +parenify e@(L _ (HsVar _)) = e +parenify e = mkHsPar 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 = nlHsPar (nlHsOpApp e1 op e2) +\end{code} + +\begin{code} +getSrcSpan = srcLocSpan . getSrcLoc +\end{code} -genOpApp e1 op e2 = mkHsOpApp e1 op e2 +\begin{code} +a_RDR = mkVarUnqual FSLIT("a") +b_RDR = mkVarUnqual FSLIT("b") +c_RDR = mkVarUnqual FSLIT("c") +d_RDR = mkVarUnqual FSLIT("d") +k_RDR = mkVarUnqual FSLIT("k") +z_RDR = mkVarUnqual FSLIT("z") +ah_RDR = mkVarUnqual FSLIT("a#") +bh_RDR = mkVarUnqual FSLIT("b#") +ch_RDR = mkVarUnqual FSLIT("c#") +dh_RDR = mkVarUnqual FSLIT("d#") +cmp_eq_RDR = mkVarUnqual FSLIT("cmp_eq") + +as_RDRs = [ mkVarUnqual (mkFastString ("a"++show i)) | i <- [(1::Int) .. ] ] +bs_RDRs = [ mkVarUnqual (mkFastString ("b"++show i)) | i <- [(1::Int) .. ] ] +cs_RDRs = [ mkVarUnqual (mkFastString ("c"++show i)) | i <- [(1::Int) .. ] ] + +a_Expr = nlHsVar a_RDR +b_Expr = nlHsVar b_RDR +c_Expr = nlHsVar c_RDR +ltTag_Expr = nlHsVar ltTag_RDR +eqTag_Expr = nlHsVar eqTag_RDR +gtTag_Expr = nlHsVar gtTag_RDR +false_Expr = nlHsVar false_RDR +true_Expr = nlHsVar true_RDR + +a_Pat = nlVarPat a_RDR +b_Pat = nlVarPat b_RDR +c_Pat = nlVarPat c_RDR +d_Pat = nlVarPat d_RDR +k_Pat = nlVarPat k_RDR +z_Pat = nlVarPat z_RDR + +con2tag_RDR, tag2con_RDR, maxtag_RDR :: TyCon -> RdrName +-- Generates Orig s RdrName, for the binding positions +con2tag_RDR tycon = mk_tc_deriv_name tycon "con2tag_" +tag2con_RDR tycon = mk_tc_deriv_name tycon "tag2con_" +maxtag_RDR tycon = mk_tc_deriv_name tycon "maxtag_" + +mk_tc_deriv_name tycon str + = mkDerivedRdrName tc_name mk_occ + where + tc_name = tyConName tycon + mk_occ tc_occ = mkVarOccFS (mkFastString new_str) + where + new_str = str ++ occNameString tc_occ ++ "#" \end{code} +s RdrName for PrimOps. Can't be done in PrelNames, because PrimOp imports +PrelNames, so PrelNames can't import PrimOp. + \begin{code} -qual_orig_name n = nameRdrName (getName n) -varUnqual n = mkUnqual varName n - -zz_a_RDR = varUnqual FSLIT("_a") -a_RDR = varUnqual FSLIT("a") -b_RDR = varUnqual FSLIT("b") -c_RDR = varUnqual FSLIT("c") -d_RDR = varUnqual FSLIT("d") -ah_RDR = varUnqual FSLIT("a#") -bh_RDR = varUnqual FSLIT("b#") -ch_RDR = varUnqual FSLIT("c#") -dh_RDR = varUnqual FSLIT("d#") -cmp_eq_RDR = varUnqual FSLIT("cmp_eq") -rangeSize_RDR = varUnqual FSLIT("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) .. ] ] - -zz_a_Expr = HsVar zz_a_RDR -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 - -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 -d_Pat = VarPatIn d_RDR - -con2tag_RDR, tag2con_RDR, maxtag_RDR :: TyCon -> RdrName - -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) ++ "#")) +primOpRdrName op = getRdrName (primOpId op) + +minusInt_RDR = primOpRdrName IntSubOp +eqInt_RDR = primOpRdrName IntEqOp +ltInt_RDR = primOpRdrName IntLtOp +geInt_RDR = primOpRdrName IntGeOp +leInt_RDR = primOpRdrName IntLeOp +tagToEnum_RDR = primOpRdrName TagToEnumOp + +error_RDR = getRdrName eRROR_ID \end{code}