-- | Remove annotations.
module Language.Lua.Annotated.Simplify where

import           Data.Maybe                    (isJust)
import           Prelude                       hiding (EQ, GT, LT)

import qualified Language.Lua.Annotated.Syntax as A
import           Language.Lua.Syntax

sName :: A.Name a -> Name
sName :: forall a. Name a -> Name
sName (A.Name a
_ Text
s) = Text -> Name
Name Text
s

sStat :: A.Stat a -> Stat
sStat :: forall a. Stat a -> Stat
sStat (A.Assign a
_ [Var a]
vs [Exp a]
es) = [Var] -> [Exp] -> Stat
Assign ((Var a -> Var) -> [Var a] -> [Var]
forall a b. (a -> b) -> [a] -> [b]
map Var a -> Var
forall a. Var a -> Var
sVar [Var a]
vs) ((Exp a -> Exp) -> [Exp a] -> [Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp a -> Exp
forall a. Exp a -> Exp
sExp [Exp a]
es)
sStat (A.FunCall a
_ FunCall a
fc) = FunCall -> Stat
FunCall (FunCall a -> FunCall
forall a. FunCall a -> FunCall
sFunCall FunCall a
fc)
sStat (A.Label a
_ Name a
n) = Name -> Stat
Label (Name a -> Name
forall a. Name a -> Name
sName Name a
n)
sStat (A.Break a
_) = Stat
Break
sStat (A.Goto a
_ Name a
n) = Name -> Stat
Goto (Name a -> Name
forall a. Name a -> Name
sName Name a
n)
sStat (A.Do a
_ Block a
b) = Block -> Stat
Do (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)
sStat (A.While a
_ Exp a
e Block a
b) = Exp -> Block -> Stat
While (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e) (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)
sStat (A.Repeat a
_ Block a
b Exp a
e) = Block -> Exp -> Stat
Repeat (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)
sStat (A.If a
_ [(Exp a, Block a)]
conds Maybe (Block a)
else_) = [(Exp, Block)] -> Maybe Block -> Stat
If (((Exp a, Block a) -> (Exp, Block))
-> [(Exp a, Block a)] -> [(Exp, Block)]
forall a b. (a -> b) -> [a] -> [b]
map (Exp a, Block a) -> (Exp, Block)
forall {a} {a}. (Exp a, Block a) -> (Exp, Block)
sCond [(Exp a, Block a)]
conds) ((Block a -> Block) -> Maybe (Block a) -> Maybe Block
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Block a -> Block
forall a. Block a -> Block
sBlock Maybe (Block a)
else_)
  where sCond :: (Exp a, Block a) -> (Exp, Block)
sCond (Exp a
e, Block a
b) = (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e, Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)
sStat (A.ForRange a
_ Name a
n Exp a
e1 Exp a
e2 Maybe (Exp a)
oe3 Block a
b) =
    Name -> Exp -> Exp -> Maybe Exp -> Block -> Stat
ForRange (Name a -> Name
forall a. Name a -> Name
sName Name a
n) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e1) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e2) ((Exp a -> Exp) -> Maybe (Exp a) -> Maybe Exp
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp a -> Exp
forall a. Exp a -> Exp
sExp Maybe (Exp a)
oe3) (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)
sStat (A.ForIn a
_ [Name a]
ns [Exp a]
es Block a
b) = [Name] -> [Exp] -> Block -> Stat
ForIn ((Name a -> Name) -> [Name a] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map Name a -> Name
forall a. Name a -> Name
sName [Name a]
ns) ((Exp a -> Exp) -> [Exp a] -> [Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp a -> Exp
forall a. Exp a -> Exp
sExp [Exp a]
es) (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)
sStat (A.FunAssign a
_ FunName a
fn FunBody a
fb) = FunName -> FunBody -> Stat
FunAssign (FunName a -> FunName
forall a. FunName a -> FunName
sFunName FunName a
fn) (FunBody a -> FunBody
forall a. FunBody a -> FunBody
sFunBody FunBody a
fb)
sStat (A.LocalFunAssign a
_ Name a
n FunBody a
fb) = Name -> FunBody -> Stat
LocalFunAssign (Name a -> Name
forall a. Name a -> Name
sName Name a
n) (FunBody a -> FunBody
forall a. FunBody a -> FunBody
sFunBody FunBody a
fb)
sStat (A.LocalAssign a
_ [Name a]
ns Maybe [Exp a]
es) = [Name] -> Maybe [Exp] -> Stat
LocalAssign ((Name a -> Name) -> [Name a] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map Name a -> Name
forall a. Name a -> Name
sName [Name a]
ns) (([Exp a] -> [Exp]) -> Maybe [Exp a] -> Maybe [Exp]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Exp a -> Exp) -> [Exp a] -> [Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp a -> Exp
forall a. Exp a -> Exp
sExp) Maybe [Exp a]
es)
sStat (A.EmptyStat a
_) = Stat
EmptyStat

sExp :: A.Exp a -> Exp
sExp :: forall a. Exp a -> Exp
sExp (A.Nil a
_) = Exp
Nil
sExp (A.Bool a
_ Bool
b) = Bool -> Exp
Bool Bool
b
sExp (A.Number a
_ NumberType
n Text
t) = NumberType -> Text -> Exp
Number NumberType
n Text
t
sExp (A.String a
_ Text
s) = Text -> Exp
String Text
s
sExp (A.Vararg a
_) = Exp
Vararg
sExp (A.EFunDef a
_ FunDef a
fd) = FunBody -> Exp
EFunDef (FunDef a -> FunBody
forall a. FunDef a -> FunBody
sFunDef FunDef a
fd)
sExp (A.PrefixExp a
_ PrefixExp a
pe) = PrefixExp -> Exp
PrefixExp (PrefixExp a -> PrefixExp
forall a. PrefixExp a -> PrefixExp
sPrefixExp PrefixExp a
pe)
sExp (A.TableConst a
_ Table a
t) = [TableField] -> Exp
TableConst (Table a -> [TableField]
forall a. Table a -> [TableField]
sTable Table a
t)
sExp (A.Binop a
_ Binop a
bop Exp a
e1 Exp a
e2) = Binop -> Exp -> Exp -> Exp
Binop (Binop a -> Binop
forall a. Binop a -> Binop
sBinop Binop a
bop) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e1) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e2)
sExp (A.Unop a
_ Unop a
uop Exp a
e) = Unop -> Exp -> Exp
Unop (Unop a -> Unop
forall a. Unop a -> Unop
sUnop Unop a
uop) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)

sBlock :: A.Block a -> Block
sBlock :: forall a. Block a -> Block
sBlock (A.Block a
_ [Stat a]
ss Maybe [Exp a]
oes) = [Stat] -> Maybe [Exp] -> Block
Block ((Stat a -> Stat) -> [Stat a] -> [Stat]
forall a b. (a -> b) -> [a] -> [b]
map Stat a -> Stat
forall a. Stat a -> Stat
sStat [Stat a]
ss) (([Exp a] -> [Exp]) -> Maybe [Exp a] -> Maybe [Exp]
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Exp a -> Exp) -> [Exp a] -> [Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp a -> Exp
forall a. Exp a -> Exp
sExp) Maybe [Exp a]
oes)

sVar :: A.Var a -> Var
sVar :: forall a. Var a -> Var
sVar (A.VarName a
_ Name a
n) = Name -> Var
VarName (Name a -> Name
forall a. Name a -> Name
sName Name a
n)
sVar (A.Select a
_ PrefixExp a
pe Exp a
e) = PrefixExp -> Exp -> Var
Select (PrefixExp a -> PrefixExp
forall a. PrefixExp a -> PrefixExp
sPrefixExp PrefixExp a
pe) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)
sVar (A.SelectName a
_ PrefixExp a
pe Name a
n) = PrefixExp -> Name -> Var
SelectName (PrefixExp a -> PrefixExp
forall a. PrefixExp a -> PrefixExp
sPrefixExp PrefixExp a
pe) (Name a -> Name
forall a. Name a -> Name
sName Name a
n)

sFunCall :: A.FunCall a -> FunCall
sFunCall :: forall a. FunCall a -> FunCall
sFunCall (A.NormalFunCall a
_ PrefixExp a
pe FunArg a
a) = PrefixExp -> FunArg -> FunCall
NormalFunCall (PrefixExp a -> PrefixExp
forall a. PrefixExp a -> PrefixExp
sPrefixExp PrefixExp a
pe) (FunArg a -> FunArg
forall a. FunArg a -> FunArg
sFunArg FunArg a
a)
sFunCall (A.MethodCall a
_ PrefixExp a
pe Name a
n FunArg a
a) = PrefixExp -> Name -> FunArg -> FunCall
MethodCall (PrefixExp a -> PrefixExp
forall a. PrefixExp a -> PrefixExp
sPrefixExp PrefixExp a
pe) (Name a -> Name
forall a. Name a -> Name
sName Name a
n) (FunArg a -> FunArg
forall a. FunArg a -> FunArg
sFunArg FunArg a
a)

sFunName :: A.FunName a -> FunName
sFunName :: forall a. FunName a -> FunName
sFunName (A.FunName a
_ Name a
n [Name a]
ns Maybe (Name a)
on) = Name -> [Name] -> Maybe Name -> FunName
FunName (Name a -> Name
forall a. Name a -> Name
sName Name a
n) ((Name a -> Name) -> [Name a] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map Name a -> Name
forall a. Name a -> Name
sName [Name a]
ns) ((Name a -> Name) -> Maybe (Name a) -> Maybe Name
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Name a -> Name
forall a. Name a -> Name
sName Maybe (Name a)
on)

sFunBody :: A.FunBody a -> FunBody
sFunBody :: forall a. FunBody a -> FunBody
sFunBody (A.FunBody a
_ [Name a]
ns Maybe a
vararg Block a
b) =
    [Name] -> Bool -> Block -> FunBody
FunBody ((Name a -> Name) -> [Name a] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map Name a -> Name
forall a. Name a -> Name
sName [Name a]
ns) (Maybe a -> Bool
forall a. Maybe a -> Bool
isJust Maybe a
vararg) (Block a -> Block
forall a. Block a -> Block
sBlock Block a
b)

sFunDef :: A.FunDef a -> FunBody
sFunDef :: forall a. FunDef a -> FunBody
sFunDef (A.FunDef a
_ FunBody a
fb) = FunBody a -> FunBody
forall a. FunBody a -> FunBody
sFunBody FunBody a
fb

sPrefixExp :: A.PrefixExp a -> PrefixExp
sPrefixExp :: forall a. PrefixExp a -> PrefixExp
sPrefixExp (A.PEVar a
_ Var a
v) = Var -> PrefixExp
PEVar (Var a -> Var
forall a. Var a -> Var
sVar Var a
v)
sPrefixExp (A.PEFunCall a
_ FunCall a
fc) = FunCall -> PrefixExp
PEFunCall (FunCall a -> FunCall
forall a. FunCall a -> FunCall
sFunCall FunCall a
fc)
sPrefixExp (A.Paren a
_ Exp a
e) = Exp -> PrefixExp
Paren (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)

sTable :: A.Table a -> [TableField]
sTable :: forall a. Table a -> [TableField]
sTable (A.Table a
_ [TableField a]
fs) = (TableField a -> TableField) -> [TableField a] -> [TableField]
forall a b. (a -> b) -> [a] -> [b]
map TableField a -> TableField
forall a. TableField a -> TableField
sTableField [TableField a]
fs

sBinop :: A.Binop a -> Binop
sBinop :: forall a. Binop a -> Binop
sBinop A.Add{} = Binop
Add
sBinop A.Sub{} = Binop
Sub
sBinop A.Mul{} = Binop
Mul
sBinop A.Div{} = Binop
Div
sBinop A.IDiv{} = Binop
IDiv
sBinop A.Exp{} = Binop
Exp
sBinop A.Mod{} = Binop
Mod
sBinop A.Concat{} = Binop
Concat
sBinop A.LT{} = Binop
LT
sBinop A.LTE{} = Binop
LTE
sBinop A.GT{} = Binop
GT
sBinop A.GTE{} = Binop
GTE
sBinop A.EQ{} = Binop
EQ
sBinop A.NEQ{} = Binop
NEQ
sBinop A.And{} = Binop
And
sBinop A.Or{} = Binop
Or
sBinop A.BAnd{} = Binop
BAnd
sBinop A.BOr{} = Binop
BOr
sBinop A.BXor{} = Binop
BXor
sBinop A.ShiftL{} = Binop
ShiftL
sBinop A.ShiftR{} = Binop
ShiftR

sUnop :: A.Unop a -> Unop
sUnop :: forall a. Unop a -> Unop
sUnop A.Neg{} = Unop
Neg
sUnop A.Not{} = Unop
Not
sUnop A.Len{} = Unop
Len
sUnop A.Complement{} = Unop
Complement

sFunArg :: A.FunArg a -> FunArg
sFunArg :: forall a. FunArg a -> FunArg
sFunArg (A.Args a
_ [Exp a]
es) = [Exp] -> FunArg
Args ((Exp a -> Exp) -> [Exp a] -> [Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp a -> Exp
forall a. Exp a -> Exp
sExp [Exp a]
es)
sFunArg (A.TableArg a
_ Table a
t) = [TableField] -> FunArg
TableArg (Table a -> [TableField]
forall a. Table a -> [TableField]
sTable Table a
t)
sFunArg (A.StringArg a
_ Text
s) = Text -> FunArg
StringArg Text
s

sTableField :: A.TableField a -> TableField
sTableField :: forall a. TableField a -> TableField
sTableField (A.ExpField a
_ Exp a
e1 Exp a
e2) = Exp -> Exp -> TableField
ExpField (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e1) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e2)
sTableField (A.NamedField a
_ Name a
n Exp a
e) = Name -> Exp -> TableField
NamedField (Name a -> Name
forall a. Name a -> Name
sName Name a
n) (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)
sTableField (A.Field a
_ Exp a
e) = Exp -> TableField
Field (Exp a -> Exp
forall a. Exp a -> Exp
sExp Exp a
e)