import HsSyn ( InPat(..), HsExpr(..), MonoBinds(..),
Match(..), GRHSs(..), Stmt(..), HsLit(..),
- HsBinds(..), StmtCtxt(..),
+ HsBinds(..), StmtCtxt(..), HsType(..),
unguardedRHS, mkSimpleMatch
)
-import RdrHsSyn ( RdrName(..), varUnqual, mkOpApp,
- RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat
+import RdrHsSyn ( mkOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat )
+import RdrName ( RdrName, mkSrcUnqual )
+import RnMonad ( Fixities )
+import BasicTypes ( RecFlag(..), Fixity(..), FixityDirection(..)
+ , maxPrecedence, defaultFixity
)
-import BasicTypes ( IfaceFlavour(..), RecFlag(..) )
import FieldLabel ( fieldLabelName )
import DataCon ( isNullaryDataCon, dataConTag,
dataConRawArgTys, fIRST_TAG,
DataCon, ConTag,
dataConFieldLabels )
import Name ( getOccString, getOccName, getSrcLoc, occNameString,
- modAndOcc, OccName, Name )
+ occNameUserString, nameRdrName, varName,
+ OccName, Name, NamedThing(..), NameSpace,
+ isDataSymOcc, isSymOcc
+ )
import PrimOp ( PrimOp(..) )
import PrelInfo -- Lots of RdrNames
import SrcLoc ( mkGeneratedSrcLoc, SrcLoc )
import TyCon ( TyCon, isNewTyCon, tyConDataCons, isEnumerationTyCon,
- maybeTyConSingleCon
+ maybeTyConSingleCon, tyConFamilySize
)
import Type ( isUnLiftedType, isUnboxedType, Type )
import TysPrim ( charPrimTy, intPrimTy, wordPrimTy, addrPrimTy,
floatPrimTy, doublePrimTy
)
import Util ( mapAccumL, zipEqual, zipWithEqual,
- zipWith3Equal, nOfThem )
+ zipWith3Equal, nOfThem, assocDefault )
import Panic ( panic, assertPanic )
import Maybes ( maybeToBool )
+import Constants
import List ( partition, intersperse )
+import Char ( isAlpha )
\end{code}
%************************************************************************
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)]
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
--------------------------------------------------------------------
-- 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] [] (
compare_Case b_Expr a_Expr a_Expr a_Expr b_Expr)
min_ = mk_easy_FunMonoBind mkGeneratedSrcLoc min_RDR [a_Pat, b_Pat] [] (
compare_Case a_Expr b_Expr b_Expr a_Expr b_Expr)
+-}
\end{code}
%************************************************************************
\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]
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] [] $
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] [] $
enum_index
= mk_easy_FunMonoBind tycon_loc index_RDR
- [AsPatIn c_RDR (TuplePatIn [a_Pat, b_Pat] True{-boxed-}),
+ [AsPatIn c_RDR (TuplePatIn [a_Pat, wildPat] True{-boxed-}),
d_Pat] [] (
HsIf (HsPar (mk_easy_App inRange_RDR [c_RDR, d_RDR])) (
untag_Expr tycon [(a_RDR, ah_RDR)] (
%* *
%************************************************************************
-Ignoring all the infix-ery mumbo jumbo (ToDo)
-
\begin{code}
-gen_Read_binds :: TyCon -> RdrNameMonoBinds
+gen_Read_binds :: Fixities -> TyCon -> RdrNameMonoBinds
-gen_Read_binds tycon
+gen_Read_binds fixities tycon
= reads_prec `AndMonoBinds` read_list
where
tycon_loc = getSrcLoc 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 (mkHsString data_con_str),
- d_Pat] True)
- (HsApp (HsVar lex_RDR) c_Expr)
- tycon_loc
-
- str_qual str res draw_from
- = BindStmt
- (TuplePatIn [LitPatIn (mkHsString str), VarPatIn res] True)
- (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 = 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
+ 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] True)
+ (HsApp (HsVar lex_RDR) c_Expr)
+ tycon_loc
+ | otherwise =
+ BindStmt
+ (TuplePatIn [LitPatIn (mkHsString data_con_str), VarPatIn bs2] True)
+ (HsApp (HsVar lex_RDR) (HsVar bs1))
+ tycon_loc
+
+
+ str_qual str res draw_from =
+ BindStmt
+ (TuplePatIn [LitPatIn (mkHsString str), VarPatIn res] True)
+ (HsApp (HsVar lex_RDR) draw_from)
+ tycon_loc
+
+ str_qual_paren str res draw_from =
+ BindStmt
+ (TuplePatIn [LitPatIn (mkHsString str), VarPatIn res] True)
+ (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 "="]
+ 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 "{":
concat (
-- The labels
(map read_label labels)
-- The fields
- (map mk_read_qual as_needed))) ++ [str_qual "}"])
+ (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] True)
- (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)] True
+ mk_read_qual p con_field res draw_from =
+ BindStmt
+ (TuplePatIn [VarPatIn con_field, VarPatIn res] True)
+ (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)] True
+
+ [lp,rp] = getLRPrecs is_infix fixities dc_nm
+ quals
+ | is_infix = let (h:t) = field_quals in (h:con_qual:t)
+ | otherwise = con_qual:field_quals
+
+ stmts = quals ++ [ReturnStmt result_expr]
+
+ {-
+ c.f. Figure 18 in Haskell 1.1 report.
+ -}
+ paren_prec_limit
+ | not is_infix = fromInt maxPrecedence
+ | otherwise = getFixity fixities 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}
%************************************************************************
%* *
%************************************************************************
-Ignoring all the infix-ery mumbo jumbo (ToDo)
-
\begin{code}
-gen_Show_binds :: TyCon -> RdrNameMonoBinds
+gen_Show_binds :: Fixities -> TyCon -> RdrNameMonoBinds
-gen_Show_binds tycon
+gen_Show_binds fixs_assoc tycon
= shows_prec `AndMonoBinds` show_list
where
tycon_loc = getSrcLoc tycon
show_list = mk_easy_FunMonoBind tycon_loc showList_RDR [] []
(HsApp (HsVar showList___RDR) (HsPar (HsApp (HsVar showsPrec_RDR) (HsLit (HsInt 0)))))
-----------------------------------------------------------------------
- shows_prec
- = mk_FunMonoBind tycon_loc showsPrec_RDR (map pats_etc (tyConDataCons tycon))
+ 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 = ""
- | lab_fields == 0 = " "
- | otherwise = "{"
-
- in
- mk_showString_app (nm ++ space_ocurly_maybe)
-
- show_all con fs
- = 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
+ | 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 = 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
+
+ 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 ++ "=")
+ 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 (mkHsString str))
+ prec_cons = getLRPrecs is_infix fixs_assoc 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 ","]) $ -- Using SLIT()s containing ,s spells trouble.
(map show_label labels)
real_show_thingies
+ (con_left_assoc, con_right_assoc) = isLRAssoc fixs_assoc dc_nm
+
+ {-
+ c.f. Figure 16 and 17 in Haskell 1.1 report
+ -}
+ paren_prec_limit
+ | not is_infix = fromInt maxPrecedence + 1
+ | otherwise = getFixity fixs_assoc dc_nm + 1
+
+\end{code}
+
+\begin{code}
+getLRPrecs :: Bool -> Fixities -> Name -> [Integer]
+getLRPrecs is_infix fixs_assoc 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 fixs_assoc nm
+ paren_con_prec = getFixity fixs_assoc nm
+ maxPrec = fromInt maxPrecedence
+
+ lp
+ | not is_infix = maxPrec + 1
+ | con_left_assoc = paren_con_prec
+ | otherwise = paren_con_prec + 1
+
+ rp
+ | not is_infix = maxPrec + 1
+ | con_right_assoc = paren_con_prec
+ | otherwise = paren_con_prec + 1
+
+getFixity :: Fixities -> Name -> Integer
+getFixity fixs_assoc nm =
+ case lookupFixity fixs_assoc nm of
+ Fixity x _ -> fromInt x
+
+isLRAssoc :: Fixities -> Name -> (Bool, Bool)
+isLRAssoc fixs_assoc nm =
+ case lookupFixity fixs_assoc nm of
+ Fixity _ InfixN -> (False, False)
+ Fixity _ InfixR -> (False, True)
+ Fixity _ InfixL -> (True, False)
+
+lookupFixity :: Fixities -> Name -> Fixity
+lookupFixity fixs_assoc nm = assocDefault defaultFixity fixs_assoc nm
+
+isInfixOccName :: String -> Bool
+isInfixOccName str =
+ case str of
+ (':':_) -> True
+ _ -> False
- in
- if nullary_con then -- skip the showParen junk...
- ASSERT(null bs_needed)
- ([a_Pat, con_pat], show_con)
- else
- ([a_Pat, con_pat],
- showParen_Expr (HsPar (genOpApp a_Expr ge_RDR (HsLit (HsInt 10))))
- (HsPar (nested_compose_Expr show_thingies)))
\end{code}
+
%************************************************************************
%* *
\subsection{Generating extra binds (@con2tag@ and @tag2con@)}
-> 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
= ([pat], HsLit (HsIntPrim (toInteger ((dataConTag var) - fIRST_TAG))))
where
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 = ([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)
+ (MonoTyVar (qual_orig_name tycon)))]
gen_tag_n_con_monobind (rdr_name, tycon, GenMaxTag)
= mk_easy_FunMonoBind (getSrcLoc tycon)
-- 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
\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 = mkSrcUnqual varName n
+zz_a_RDR = varUnqual SLIT("_a")
a_RDR = varUnqual SLIT("a")
b_RDR = varUnqual SLIT("b")
c_RDR = varUnqual SLIT("c")
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
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
projects / ghc-hetmet.git / blobdiff