amelia
/
ahc


{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

module Frontend.Syntax where


import qualified Data.Text as T

import Data.Text (Text)


import Development.Shake.Classes (Binary, Hashable, NFData)


import Frontend.Parser.Posn

import Frontend.Syntax.Var


import GHC.Generics (Generic)


data FeExpr var

 = Ref var

 | Con var

 | App (FeExpr var) (FeExpr var)

 | Lam (FePat var) (FeExpr var)

 | Let [FeDecl var] (FeExpr var)

 | Tuple [FeExpr var]

 | Annot (FeExpr var) (FeType var)

 | Infix (FeExpr var) var (FeExpr var)


 | Literal Literal


 | ParenExp (FeExpr var)

 | SPExpr (FeExpr var) Posn Posn

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (FeExpr var) where

 startPosn (SPExpr _ s _) = s

 startPosn _ = error "no start posn in parsed expression?"


 endPosn (SPExpr _ _ e) = e

 endPosn _ = error "no end posn in parsed expression?"


 span sp ep (SPExpr x _ _) = SPExpr x (startPosn sp) (endPosn ep)

 span sp ep x = SPExpr x (startPosn sp) (endPosn ep)


data FePat var

 = Var var

 | Wildcard


 | TupPat [FePat var]

 | LitPat Literal

 | ConPat var [FePat var]

 | InfixPat (FePat var) var (FePat var)


 | ParenPat (FePat var) -- parsed parentheses

 | SPPat (FePat var) Posn Posn

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (FePat var) where

 startPosn (SPPat _ s _) = s

 startPosn _ = error "no start posn in parsed expression?"


 endPosn (SPPat _ _ e) = e

 endPosn _ = error "no end posn in parsed pattern?"


 span sp ep (SPPat x _ _) = SPPat x (startPosn sp) (endPosn ep)

 span sp ep x = SPPat x (startPosn sp) (endPosn ep)


data FeType var

 = Tyvar var

 | Tycon var

 | Tyapp (FeType var) (FeType var)

 | Tyarr (FeType var) (FeType var)

 | Tytup [FeType var]

 | Tylist (FeType var)


 | ParenType (FeType var) -- parsed parentheses

 | SPType (FeType var) Posn Posn

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (FeType var) where

 startPosn (SPType _ s _) = s

 startPosn _ = error "no start posn in parsed type?"


 endPosn (SPType _ _ e) = e

 endPosn _ = error "no end posn in parsed type?"


 span sp ep (SPType x _ _) = SPType x (startPosn sp) (endPosn ep)

 span sp ep x = SPType x (startPosn sp) (endPosn ep)


data FeDecl var

 = PatDecl { pdPat :: FePat var

 , declRhs :: FeRhs var

 , declBegin :: Posn

 , declEnd :: Posn }

 | FunDecl { fdVar :: var

 , fdArgs :: [FePat var]

 , declRhs :: FeRhs var

 , declBegin :: Posn

 , declEnd :: Posn }

 | TySig { tsVars :: [var]

 , tsType :: FeType var

 , declBegin :: Posn

 , declEnd :: Posn }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (FeDecl var) where

 startPosn = declBegin

 endPosn = declEnd


 span sp ep s = s { declBegin = startPosn sp, declEnd = endPosn ep }


data FeRhs var

 = BareRhs { bareRhs :: FeExpr var

 , rhsWhere :: [FeDecl var]

 , rhsBegin :: Posn

 , rhsEnd :: Posn }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (FeRhs var) where

 startPosn = rhsBegin

 endPosn = rhsEnd


 span sp ep s = s { rhsBegin = startPosn sp, rhsEnd = endPosn ep }


data Literal

 = LitString T.Text

 | LitNumber Integer

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


data FeModule var

 = Module { moduleName :: var

 , moduleExports :: Maybe [NamespacedItem var]

 , moduleImports :: [ModuleImport var]

 , moduleItems :: [ModuleItem var]

 }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


data ModuleImport var

 = Import { importMod :: var

 , importList :: Maybe [NamespacedItem var]

 , importQualified :: Bool

 , importAlias :: Maybe var

 , importBegin :: Posn

 , importEnd :: Posn

 }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn (ModuleImport var) where

 startPosn = importBegin

 endPosn = importEnd


 span sp ep s = s { importBegin = startPosn sp, importEnd = endPosn ep }


data NamespacedItem var

 = IEVar var

 | IECon var

 | IEModule var

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


data ModuleItem var

 = ModDecl { itemDecl :: FeDecl var, itemBegin :: Posn, itemEnd :: Posn }

 | ModImport { itemImport :: ModuleImport var, itemBegin :: Posn, itemEnd :: Posn }

 | ModFfi { itemForeign :: FfiItem var, itemBegin :: Posn, itemEnd :: Posn }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


data FfiItem var

 = FfiImport

 { fiVarName :: var

 , fiType :: FeType var

 , fiCallConv :: FfiCallConv

 , fiSafety :: Maybe FfiSafety

 , fiItem :: Maybe FfiImpEnt

 , fiBegin :: Posn

 , fiEnd :: Posn

 }

 | FfiExport

 { fiVarName :: var

 , fiType :: FeType var

 , fiCallConv :: FfiCallConv

 , fiExpCid :: Maybe Text

 , fiBegin :: Posn

 , fiEnd :: Posn

 }

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


data FfiCallConv = CC_CCall deriving (Eq, Show, Ord, Generic, Binary, Hashable, NFData)

data FfiSafety = Safe | Unsafe deriving (Eq, Show, Ord, Generic, Binary, Hashable, NFData)

data FfiImpEnt

 = ForeignItem

 { fiItemName :: Maybe Text

 , fiHeader :: Maybe Text

 , fiStatic :: Bool

 , fiIsRef :: Bool

 }

 | Dynamic

 | Wrapper

 deriving (Eq, Show, Generic, Binary, Hashable, NFData)


instance HasPosn ParsedVar where

 startPosn = varBegin

 endPosn = varEnd


 span sp ep s = s { varBegin = startPosn sp, varEnd = endPosn ep }


instance HasPosn (ModuleItem var) where

 startPosn = itemBegin

 endPosn = itemEnd


 span sp ep s = s { itemBegin = startPosn sp, itemEnd = endPosn ep }


instance HasPosn (FfiItem var) where

 startPosn = fiBegin

 endPosn = fiEnd


 span sp ep s = s { fiBegin = startPosn sp, fiEnd = endPosn ep }