import HsSyn as Hs
( HsExpr(..), HsLit(..), ArithSeqInfo(..),
- HsStmtContext(..), TyClDecl(..),
+ HsStmtContext(..), TyClDecl(..), HsBang(..),
Match(..), GRHSs(..), GRHS(..), HsPred(..),
HsDecl(..), TyClDecl(..), InstDecl(..), ConDecl(..),
Stmt(..), HsBinds(..), MonoBinds(..), Sig(..),
Pat(..), HsConDetails(..), HsOverLit, BangType(..),
- placeHolderType, HsType(..), HsTupCon(..),
+ placeHolderType, HsType(..), HsExplicitForAll(..),
HsTyVarBndr(..), HsContext,
- mkSimpleMatch
+ mkSimpleMatch, mkImplicitHsForAllTy, mkExplicitHsForAllTy
)
import RdrName ( RdrName, mkRdrUnqual, mkRdrQual, mkOrig )
import RdrHsSyn ( mkHsIntegral, mkHsFractional, mkClassDecl, mkTyData )
import OccName
import SrcLoc ( SrcLoc, generatedSrcLoc )
-import TyCon ( DataConDetails(..) )
import Type ( Type )
-import BasicTypes( Boxity(..), RecFlag(Recursive),
- NewOrData(..), StrictnessMark(..) )
-import ForeignCall ( Safety(..), CCallConv(..), CCallTarget(..) )
-import HsDecls ( CImportSpec(..), ForeignImport(..), ForeignDecl(..) )
+import BasicTypes( Boxity(..), RecFlag(Recursive), NewOrData(..) )
+import ForeignCall ( Safety(..), CCallConv(..), CCallTarget(..),
+ CExportSpec(..))
+import HsDecls ( CImportSpec(..), ForeignImport(..), ForeignExport(..),
+ ForeignDecl(..) )
import FastString( FastString, mkFastString, nilFS )
import Char ( ord, isAscii, isAlphaNum, isAlpha )
import List ( partition )
convertToHsDecls :: [Meta.Dec] -> [Either (HsDecl RdrName) Message]
convertToHsDecls ds = map cvt_top ds
+mk_con con = case con of
+ NormalC c strtys
+ -> ConDecl (cName c) noExistentials noContext
+ (PrefixCon (map mk_arg strtys)) loc0
+ RecC c varstrtys
+ -> ConDecl (cName c) noExistentials noContext
+ (RecCon (map mk_id_arg varstrtys)) loc0
+ InfixC st1 c st2
+ -> ConDecl (cName c) noExistentials noContext
+ (InfixCon (mk_arg st1) (mk_arg st2)) loc0
+ where
+ mk_arg (IsStrict, ty) = BangType HsStrict (cvtType ty)
+ mk_arg (NotStrict, ty) = BangType HsNoBang (cvtType ty)
+
+ mk_id_arg (i, IsStrict, ty)
+ = (vName i, BangType HsStrict (cvtType ty))
+ mk_id_arg (i, NotStrict, ty)
+ = (vName i, BangType HsNoBang (cvtType ty))
+
+mk_derivs [] = Nothing
+mk_derivs cs = Just [HsClassP (tconName c) [] | c <- cs]
cvt_top :: Meta.Dec -> Either (HsDecl RdrName) Message
-cvt_top d@(Val _ _ _) = Left $ ValD (cvtd d)
-cvt_top d@(Fun _ _) = Left $ ValD (cvtd d)
+cvt_top d@(Meta.ValD _ _ _) = Left $ Hs.ValD (cvtd d)
+cvt_top d@(Meta.FunD _ _) = Left $ Hs.ValD (cvtd d)
-cvt_top (TySyn tc tvs rhs)
+cvt_top (TySynD tc tvs rhs)
= Left $ TyClD (TySynonym (tconName tc) (cvt_tvs tvs) (cvtType rhs) loc0)
-cvt_top (Data tc tvs constrs derivs)
+cvt_top (DataD ctxt tc tvs constrs derivs)
= Left $ TyClD (mkTyData DataType
- (noContext, tconName tc, cvt_tvs tvs)
- (DataCons (map mk_con constrs))
+ (cvt_context ctxt, tconName tc, cvt_tvs tvs)
+ (map mk_con constrs)
(mk_derivs derivs) loc0)
- where
- mk_con (Constr c tys)
- = ConDecl (cName c) noExistentials noContext
- (PrefixCon (map mk_arg tys)) loc0
-
- mk_arg ty = BangType NotMarkedStrict (cvtType ty)
- mk_derivs [] = Nothing
- mk_derivs cs = Just [HsClassP (tconName c) [] | c <- cs]
+cvt_top (NewtypeD ctxt tc tvs constr derivs)
+ = Left $ TyClD (mkTyData NewType
+ (cvt_context ctxt, tconName tc, cvt_tvs tvs)
+ [mk_con constr]
+ (mk_derivs derivs) loc0)
-cvt_top (Class ctxt cl tvs decs)
+cvt_top (ClassD ctxt cl tvs decs)
= Left $ TyClD (mkClassDecl (cvt_context ctxt, tconName cl, cvt_tvs tvs)
- noFunDeps
- sigs (Just binds) loc0)
+ noFunDeps sigs
+ binds loc0)
where
(binds,sigs) = cvtBindsAndSigs decs
-cvt_top (Instance tys ty decs)
- = Left $ InstD (InstDecl inst_ty binds sigs Nothing loc0)
+cvt_top (InstanceD tys ty decs)
+ = Left $ InstD (InstDecl inst_ty binds sigs loc0)
where
(binds, sigs) = cvtBindsAndSigs decs
- inst_ty = HsForAllTy Nothing
- (cvt_context tys)
- (HsPredTy (cvt_pred ty))
+ inst_ty = mkImplicitHsForAllTy (cvt_context tys) (HsPredTy (cvt_pred ty))
-cvt_top (Proto nm typ) = Left $ SigD (Sig (vName nm) (cvtType typ) loc0)
+cvt_top (Meta.SigD nm typ) = Left $ Hs.SigD (Sig (vName nm) (cvtType typ) loc0)
-cvt_top (Foreign (Import callconv safety from nm typ))
+cvt_top (ForeignD (ImportF callconv safety from nm typ))
= case parsed of
Just (c_header, cis) ->
let i = CImport callconv' safety' c_header nilFS cis
Threadsafe -> PlaySafe True
parsed = parse_ccall_impent nm from
+cvt_top (ForeignD (ExportF callconv as nm typ))
+ = let e = CExport (CExportStatic (mkFastString as) callconv')
+ in Left $ ForD (ForeignExport (vName nm) (cvtType typ) e False loc0)
+ where callconv' = case callconv of
+ CCall -> CCallConv
+ StdCall -> StdCallConv
+
parse_ccall_impent :: String -> String -> Maybe (FastString, CImportSpec)
parse_ccall_impent nm s
= case lex_ccall_impent s of
convertToHsExpr :: Meta.Exp -> HsExpr RdrName
convertToHsExpr = cvt
-cvt (Var s) = HsVar(vName s)
-cvt (Con s) = HsVar(cName s)
-cvt (Lit l)
+cvt (VarE s) = HsVar (vName s)
+cvt (ConE s) = HsVar (cName s)
+cvt (LitE l)
| overloadedLit l = HsOverLit (cvtOverLit l)
| otherwise = HsLit (cvtLit l)
-cvt (App x y) = HsApp (cvt x) (cvt y)
-cvt (Lam ps e) = HsLam (mkSimpleMatch (map cvtp ps) (cvt e) void loc0)
-cvt (Tup es) = ExplicitTuple(map cvt es) Boxed
-cvt (Cond x y z) = HsIf (cvt x) (cvt y) (cvt z) loc0
-cvt (Let ds e) = HsLet (cvtdecs ds) (cvt e)
-cvt (Case e ms) = HsCase (cvt e) (map cvtm ms) loc0
-cvt (Do ss) = HsDo DoExpr (cvtstmts ss) [] void loc0
-cvt (Comp ss) = HsDo ListComp (cvtstmts ss) [] void loc0
-cvt (ArithSeq dd) = ArithSeqIn (cvtdd dd)
-cvt (ListExp xs) = ExplicitList void (map cvt xs)
-cvt (Infix (Just x) s (Just y))
- = HsPar (OpApp (cvt x) (HsVar(vName s)) undefined (cvt y))
-cvt (Infix Nothing s (Just y)) = SectionR (HsVar(vName s)) (cvt y)
-cvt (Infix (Just x) s Nothing ) = SectionL (cvt x) (HsVar(vName s))
-cvt (Infix Nothing s Nothing ) = HsVar(vName s) -- Can I indicate this is an infix thing?
-cvt (SigExp e t) = ExprWithTySig (cvt e) (cvtType t)
+cvt (AppE x y) = HsApp (cvt x) (cvt y)
+cvt (LamE ps e) = HsLam (mkSimpleMatch (map cvtp ps) (cvt e) void loc0)
+cvt (TupE [e]) = cvt e
+cvt (TupE es) = ExplicitTuple(map cvt es) Boxed
+cvt (CondE x y z) = HsIf (cvt x) (cvt y) (cvt z) loc0
+cvt (LetE ds e) = HsLet (cvtdecs ds) (cvt e)
+cvt (CaseE e ms) = HsCase (cvt e) (map cvtm ms) loc0
+cvt (DoE ss) = HsDo DoExpr (cvtstmts ss) [] void loc0
+cvt (CompE ss) = HsDo ListComp (cvtstmts ss) [] void loc0
+cvt (ArithSeqE dd) = ArithSeqIn (cvtdd dd)
+cvt (ListE xs) = ExplicitList void (map cvt xs)
+cvt (InfixE (Just x) s (Just y))
+ = HsPar (OpApp (cvt x) (cvt s) undefined (cvt y))
+cvt (InfixE Nothing s (Just y)) = SectionR (cvt s) (cvt y)
+cvt (InfixE (Just x) s Nothing ) = SectionL (cvt x) (cvt s)
+cvt (InfixE Nothing s Nothing ) = cvt s -- Can I indicate this is an infix thing?
+cvt (SigE e t) = ExprWithTySig (cvt e) (cvtType t)
+cvt (RecConE c flds) = RecordCon (cName c) (map (\(x,y) -> (vName x, cvt y)) flds)
+cvt (RecUpdE e flds) = RecordUpd (cvt e) (map (\(x,y) -> (vName x, cvt y)) flds)
cvtdecs :: [Meta.Dec] -> HsBinds RdrName
cvtdecs [] = EmptyBinds
where
(sigs, non_sigs) = partition sigP ds
-cvtSig (Proto nm typ) = Sig (vName nm) (cvtType typ) loc0
+cvtSig (Meta.SigD nm typ) = Hs.Sig (vName nm) (cvtType typ) loc0
cvtds :: [Meta.Dec] -> MonoBinds RdrName
cvtds [] = EmptyMonoBinds
cvtd :: Meta.Dec -> MonoBinds RdrName
-- Used only for declarations in a 'let/where' clause,
-- not for top level decls
-cvtd (Val (Pvar s) body ds) = FunMonoBind (vName s) False
+cvtd (Meta.ValD (Meta.VarP s) body ds) = FunMonoBind (vName s) False
[cvtclause (Clause [] body ds)] loc0
-cvtd (Fun nm cls) = FunMonoBind (vName nm) False (map cvtclause cls) loc0
-cvtd (Val p body ds) = PatMonoBind (cvtp p) (GRHSs (cvtguard body)
+cvtd (FunD nm cls) = FunMonoBind (vName nm) False (map cvtclause cls) loc0
+cvtd (Meta.ValD p body ds) = PatMonoBind (cvtp p) (GRHSs (cvtguard body)
(cvtdecs ds)
void) loc0
cvtd x = panic "Illegal kind of declaration in where clause"
-cvtclause :: Meta.Clause (Meta.Pat) (Meta.Exp) (Meta.Dec) -> Hs.Match RdrName
+cvtclause :: Meta.Clause -> Hs.Match RdrName
cvtclause (Clause ps body wheres)
- = Match (map cvtp ps) Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
-
+ = Hs.Match (map cvtp ps) Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
-cvtdd :: Meta.DDt -> ArithSeqInfo RdrName
-cvtdd (Meta.From x) = (Hs.From (cvt x))
-cvtdd (Meta.FromThen x y) = (Hs.FromThen (cvt x) (cvt y))
-cvtdd (Meta.FromTo x y) = (Hs.FromTo (cvt x) (cvt y))
-cvtdd (Meta.FromThenTo x y z) = (Hs.FromThenTo (cvt x) (cvt y) (cvt z))
+cvtdd :: Range -> ArithSeqInfo RdrName
+cvtdd (FromR x) = (From (cvt x))
+cvtdd (FromThenR x y) = (FromThen (cvt x) (cvt y))
+cvtdd (FromToR x y) = (FromTo (cvt x) (cvt y))
+cvtdd (FromThenToR x y z) = (FromThenTo (cvt x) (cvt y) (cvt z))
-cvtstmts :: [Meta.Stm] -> [Hs.Stmt RdrName]
-cvtstmts [] = [] -- this is probably an error as every [stmt] should end with ResultStmt
-cvtstmts [NoBindSt e] = [ResultStmt (cvt e) loc0] -- when its the last element use ResultStmt
-cvtstmts (NoBindSt e : ss) = ExprStmt (cvt e) void loc0 : cvtstmts ss
-cvtstmts (BindSt p e : ss) = BindStmt (cvtp p) (cvt e) loc0 : cvtstmts ss
-cvtstmts (LetSt ds : ss) = LetStmt (cvtdecs ds) : cvtstmts ss
-cvtstmts (ParSt dss : ss) = ParStmt(map cvtstmts dss) : cvtstmts ss
+cvtstmts :: [Meta.Stmt] -> [Hs.Stmt RdrName]
+cvtstmts [] = [] -- this is probably an error as every [stmt] should end with ResultStmt
+cvtstmts [NoBindS e] = [ResultStmt (cvt e) loc0] -- when its the last element use ResultStmt
+cvtstmts (NoBindS e : ss) = ExprStmt (cvt e) void loc0 : cvtstmts ss
+cvtstmts (Meta.BindS p e : ss) = BindStmt (cvtp p) (cvt e) loc0 : cvtstmts ss
+cvtstmts (Meta.LetS ds : ss) = LetStmt (cvtdecs ds) : cvtstmts ss
+cvtstmts (Meta.ParS dss : ss) = ParStmt [(cvtstmts ds, undefined) | ds <- dss] : cvtstmts ss
-cvtm :: Meta.Mat -> Hs.Match RdrName
-cvtm (Mat p body wheres)
- = Match [cvtp p] Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
+cvtm :: Meta.Match -> Hs.Match RdrName
+cvtm (Meta.Match p body wheres)
+ = Hs.Match [cvtp p] Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
-cvtguard :: Meta.Rhs -> [GRHS RdrName]
-cvtguard (Guarded pairs) = map cvtpair pairs
-cvtguard (Normal e) = [GRHS [ ResultStmt (cvt e) loc0 ] loc0]
+cvtguard :: Meta.Body -> [GRHS RdrName]
+cvtguard (GuardedB pairs) = map cvtpair pairs
+cvtguard (NormalB e) = [GRHS [ ResultStmt (cvt e) loc0 ] loc0]
cvtpair :: (Meta.Exp,Meta.Exp) -> GRHS RdrName
-cvtpair (x,y) = GRHS [BindStmt truePat (cvt x) loc0,
+cvtpair (x,y) = GRHS [Hs.BindStmt truePat (cvt x) loc0,
ResultStmt (cvt y) loc0] loc0
cvtOverLit :: Lit -> HsOverLit
-cvtOverLit (Integer i) = mkHsIntegral i
-cvtOverLit (Rational r) = mkHsFractional r
+cvtOverLit (IntegerL i) = mkHsIntegral i
+cvtOverLit (RationalL r) = mkHsFractional r
-- An Integer is like an an (overloaded) '3' in a Haskell source program
-- Similarly 3.5 for fractionals
cvtLit :: Lit -> HsLit
-cvtLit (Char c) = HsChar (ord c)
-cvtLit (String s) = HsString (mkFastString s)
+cvtLit (IntPrimL i) = HsIntPrim i
+cvtLit (FloatPrimL f) = HsFloatPrim f
+cvtLit (DoublePrimL f) = HsDoublePrim f
+cvtLit (CharL c) = HsChar (ord c)
+cvtLit (StringL s) = HsString (mkFastString s)
cvtp :: Meta.Pat -> Hs.Pat RdrName
-cvtp (Plit l)
+cvtp (Meta.LitP l)
| overloadedLit l = NPatIn (cvtOverLit l) Nothing -- Not right for negative
-- patterns; need to think
-- about that!
- | otherwise = LitPat (cvtLit l)
-cvtp (Pvar s) = VarPat(vName s)
-cvtp (Ptup ps) = TuplePat (map cvtp ps) Boxed
-cvtp (Pcon s ps) = ConPatIn (cName s) (PrefixCon (map cvtp ps))
-cvtp (Ptilde p) = LazyPat (cvtp p)
-cvtp (Paspat s p) = AsPat (vName s) (cvtp p)
-cvtp Pwild = WildPat void
+ | otherwise = Hs.LitPat (cvtLit l)
+cvtp (Meta.VarP s) = Hs.VarPat(vName s)
+cvtp (TupP [p]) = cvtp p
+cvtp (TupP ps) = TuplePat (map cvtp ps) Boxed
+cvtp (ConP s ps) = ConPatIn (cName s) (PrefixCon (map cvtp ps))
+cvtp (TildeP p) = LazyPat (cvtp p)
+cvtp (Meta.AsP s p) = AsPat (vName s) (cvtp p)
+cvtp Meta.WildP = WildPat void
+cvtp (RecP c fs) = ConPatIn (cName c) $ Hs.RecCon (map (\(s,p) -> (vName s,cvtp p)) fs)
+cvtp (ListP ps) = ListPat (map cvtp ps) void
-----------------------------------------------------------
-- Types and type variables
cvt_context :: Cxt -> HsContext RdrName
cvt_context tys = map cvt_pred tys
-cvt_pred :: Typ -> HsPred RdrName
+cvt_pred :: Meta.Type -> HsPred RdrName
cvt_pred ty = case split_ty_app ty of
- (Tvar tc, tys) -> HsClassP (tconName tc) (map cvtType tys)
- other -> panic "Malformed predicate"
+ (ConT tc, tys) -> HsClassP (tconName tc) (map cvtType tys)
+ other -> pprPanic "Malformed predicate" (ppr ty)
-cvtType :: Meta.Typ -> HsType RdrName
+cvtType :: Meta.Type -> HsType RdrName
cvtType ty = trans (root ty [])
- where root (Tapp a b) zs = root a (cvtType b : zs)
+ where root (AppT a b) zs = root a (cvtType b : zs)
root t zs = (t,zs)
- trans (Tcon (Tuple n),args) | length args == n
- = HsTupleTy (HsTupCon Boxed n) args
- trans (Tcon Arrow, [x,y]) = HsFunTy x y
- trans (Tcon List, [x]) = HsListTy x
+ trans (TupleT n,args)
+ | length args == n = HsTupleTy Boxed args
+ | n == 0 = foldl HsAppTy (HsTyVar (tconName "()")) args
+ | otherwise = foldl HsAppTy (HsTyVar (tconName ("(" ++ replicate (n-1) ',' ++ ")"))) args
+ trans (ArrowT, [x,y]) = HsFunTy x y
+ trans (ListT, [x]) = HsListTy x
- trans (Tvar nm, args) = foldl HsAppTy (HsTyVar (tName nm)) args
- trans (Tcon tc, args) = foldl HsAppTy (HsTyVar (tc_name tc)) args
+ trans (VarT nm, args) = foldl HsAppTy (HsTyVar (tName nm)) args
+ trans (ConT tc, args) = foldl HsAppTy (HsTyVar (tconName tc)) args
- tc_name (TconName nm) = tconName nm
- tc_name Arrow = tconName "->"
- tc_name List = tconName "[]"
- tc_name (Tuple 0) = tconName "()"
- tc_name (Tuple n) = tconName ("(" ++ replicate (n-1) ',' ++ ")")
+ trans (ForallT tvs cxt ty, []) = mkExplicitHsForAllTy
+ (cvt_tvs tvs) (cvt_context cxt) (cvtType ty)
-split_ty_app :: Typ -> (Typ, [Typ])
+split_ty_app :: Meta.Type -> (Meta.Type, [Meta.Type])
split_ty_app ty = go ty []
where
- go (Tapp f a) as = go f (a:as)
+ go (AppT f a) as = go f (a:as)
go f as = (f,as)
-----------------------------------------------------------
sigP :: Dec -> Bool
-sigP (Proto _ _) = True
+sigP (Meta.SigD _ _) = True
sigP other = False
overloadedLit :: Lit -> Bool
-- True for literals that Haskell treats as overloaded
-overloadedLit (Integer l) = True
-overloadedLit (Rational l) = True
-overloadedLit l = False
+overloadedLit (IntegerL l) = True
+overloadedLit (RationalL l) = True
+overloadedLit l = False
void :: Type.Type
void = placeHolderType
vName :: String -> RdrName
vName = mkName varName
--- Constructor function names
+-- Constructor function names; this is Haskell source, hence srcDataName
cName :: String -> RdrName
-cName = mkName dataName
+cName = mkName srcDataName
-- Type variable names
tName :: String -> RdrName
is_sep ':' = True
is_sep other = False
\end{code}
+