{-# OPTIONS_HADDOCK hide #-}

{-# LANGUAGE DataKinds                #-}
{-# LANGUAGE FlexibleContexts         #-}
{-# LANGUAGE FlexibleInstances        #-}
{-# LANGUAGE GADTs                    #-}
{-# LANGUAGE KindSignatures           #-}
{-# LANGUAGE MultiParamTypeClasses    #-}
{-# LANGUAGE PartialTypeSignatures    #-}
{-# LANGUAGE ScopedTypeVariables      #-}
{-# LANGUAGE ViewPatterns             #-}
{-# LANGUAGE TemplateHaskell          #-}
{-# LANGUAGE TypeApplications         #-}
{-# LANGUAGE TypeOperators            #-}
{-# LANGUAGE UndecidableInstances     #-}

module Cubix.Language.Lua.Parametric.Common.Trans (
    translate
  , untranslate
  ) where

import Data.List( (\\) )
import Data.Maybe ( fromJust )
import Language.Haskell.TH.Syntax ( Type(ConT), Exp(VarE) )
import Data.Proxy
import Data.Text ( pack, unpack )

import Data.Comp.Multi ( project, inject, unTerm, (:-<:), Sum, All, caseCxt
                       , HFunctor(..) )

import Cubix.Language.Lua.Parametric.Common.Types
import qualified Cubix.Language.Lua.Parametric.Full as F
import Cubix.Language.Parametric.Derive
import Cubix.Language.Parametric.InjF
import Cubix.Language.Parametric.Syntax

translate :: F.LuaTerm l -> MLuaTerm l
translate :: LuaTerm l -> MLuaTerm l
translate = Sum LuaSig LuaTerm l -> MLuaTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f LuaTerm l -> MLuaTerm l
trans (Sum LuaSig LuaTerm l -> MLuaTerm l)
-> (LuaTerm l -> Sum LuaSig LuaTerm l) -> LuaTerm l -> MLuaTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LuaTerm l -> Sum LuaSig LuaTerm l
forall (f :: (* -> *) -> * -> *) t. HFix f t -> f (HFix f) t
unTerm

class Trans f where
  trans :: f F.LuaTerm l -> MLuaTerm l

instance {-# OVERLAPPING #-} (All Trans fs) => Trans (Sum fs) where
  trans :: Sum fs LuaTerm l -> MLuaTerm l
trans = Proxy Trans
-> (forall (f :: (* -> *) -> * -> *).
    Trans f =>
    f LuaTerm l -> MLuaTerm l)
-> Sum fs LuaTerm l
-> MLuaTerm l
forall (cxt :: ((* -> *) -> * -> *) -> Constraint)
       (fs :: [(* -> *) -> * -> *]) (a :: * -> *) e b.
All cxt fs =>
Proxy cxt
-> (forall (f :: (* -> *) -> * -> *). cxt f => f a e -> b)
-> Sum fs a e
-> b
caseCxt (Proxy Trans
forall k (t :: k). Proxy t
Proxy @Trans) forall (f :: (* -> *) -> * -> *).
Trans f =>
f LuaTerm l -> MLuaTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f LuaTerm l -> MLuaTerm l
trans

transDefault :: (HFunctor f, f :-<: MLuaSig, f :-<: F.LuaSig) => f F.LuaTerm l -> MLuaTerm l
transDefault :: f LuaTerm l -> MLuaTerm l
transDefault = f (Cxt NoHole (Sum MLuaSig) (K ())) l -> MLuaTerm l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum MLuaSig) (K ())) l -> MLuaTerm l)
-> (f LuaTerm l -> f (Cxt NoHole (Sum MLuaSig) (K ())) l)
-> f LuaTerm l
-> MLuaTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ()))
-> f LuaTerm :-> f (Cxt NoHole (Sum MLuaSig) (K ()))
forall (h :: (* -> *) -> * -> *) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: MLuaSig, f :-<: F.LuaSig) => Trans f where
  trans :: f LuaTerm l -> MLuaTerm l
trans = f LuaTerm l -> MLuaTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MLuaSig, f :-<: LuaSig) =>
f LuaTerm l -> MLuaTerm l
transDefault

transIdent :: F.LuaTerm F.NameL -> MLuaTerm IdentL
transIdent :: LuaTerm NameL -> MLuaTerm IdentL
transIdent (LuaTerm NameL -> Maybe (Name LuaTerm NameL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Name n :: Text
n)) = String -> MLuaTerm IdentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Ident :-<: fs, All HFunctor fs) =>
String -> CxtS h fs a IdentL
Ident' (String -> MLuaTerm IdentL) -> String -> MLuaTerm IdentL
forall a b. (a -> b) -> a -> b
$ Text -> String
unpack Text
n


transBlock :: F.LuaTerm F.BlockL -> MLuaTerm BlockL
transBlock :: LuaTerm BlockL -> MLuaTerm BlockL
transBlock (LuaTerm BlockL -> Maybe (Block LuaTerm BlockL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Block s :: Cxt NoHole (Sum LuaSig) (K ()) [StatL]
s e :: Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
e)) = CxtS NoHole MLuaSig (K ()) [BlockItemL]
-> CxtS NoHole MLuaSig (K ()) BlockEndL -> MLuaTerm BlockL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Block :-<: fs, All HFunctor fs) =>
CxtS h fs a [BlockItemL]
-> CxtS h fs a BlockEndL -> CxtS h fs a BlockL
Block' ((Cxt NoHole (Sum LuaSig) (K ()) StatL
 -> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL)
-> Cxt NoHole (Sum LuaSig) (K ()) [StatL]
-> CxtS NoHole MLuaSig (K ()) [BlockItemL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF (CxtS NoHole MLuaSig (K ()) StatL
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF(CxtS NoHole MLuaSig (K ()) StatL
 -> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL)
-> (Cxt NoHole (Sum LuaSig) (K ()) StatL
    -> CxtS NoHole MLuaSig (K ()) StatL)
-> Cxt NoHole (Sum LuaSig) (K ()) StatL
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum LuaSig) (K ()) StatL
-> CxtS NoHole MLuaSig (K ()) StatL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate) Cxt NoHole (Sum LuaSig) (K ()) [StatL]
s) (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> CxtS NoHole MLuaSig (K ()) BlockEndL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
 -> CxtS NoHole MLuaSig (K ()) BlockEndL)
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> CxtS NoHole MLuaSig (K ()) BlockEndL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
e)

instance Trans F.Block where
  trans :: Block LuaTerm l -> MLuaTerm l
trans b :: Block LuaTerm l
b@(F.Block _ _) = MLuaTerm BlockL -> MLuaTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MLuaTerm BlockL -> MLuaTerm l) -> MLuaTerm BlockL -> MLuaTerm l
forall a b. (a -> b) -> a -> b
$ LuaTerm BlockL -> MLuaTerm BlockL
transBlock (LuaTerm BlockL -> MLuaTerm BlockL)
-> LuaTerm BlockL -> MLuaTerm BlockL
forall a b. (a -> b) -> a -> b
$ Block LuaTerm l -> Cxt NoHole (Sum LuaSig) (K ()) l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject Block LuaTerm l
b

instance Trans F.Name where
  trans :: Name LuaTerm l -> MLuaTerm l
trans (F.Name n :: Text
n) = String -> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
iIdent (String -> MLuaTerm l) -> String -> MLuaTerm l
forall a b. (a -> b) -> a -> b
$ Text -> String
unpack Text
n

transParams :: F.LuaTerm [F.NameL] -> Bool -> MLuaTerm [FunctionParameterL]
transParams :: LuaTerm [NameL] -> Bool -> MLuaTerm [FunctionParameterL]
transParams nms :: LuaTerm [NameL]
nms varArg :: Bool
varArg = [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> MLuaTerm [FunctionParameterL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
 -> MLuaTerm [FunctionParameterL])
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> MLuaTerm [FunctionParameterL]
forall a b. (a -> b) -> a -> b
$ ((LuaTerm NameL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL)
-> [LuaTerm NameL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a b. (a -> b) -> [a] -> [b]
map LuaTerm NameL -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
makeParam ([LuaTerm NameL]
 -> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL])
-> [LuaTerm NameL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a b. (a -> b) -> a -> b
$ LuaTerm [NameL] -> [LuaTerm NameL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF LuaTerm [NameL]
nms) [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a. [a] -> [a] -> [a]
++ (if Bool
varArg then [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaVarArgsParam :-<: fs, InjF fs FunctionParameterL j) =>
CxtS h fs a j
iLuaVarArgsParam] else [])
  where
    makeParam :: F.LuaTerm F.NameL -> MLuaTerm FunctionParameterL
    makeParam :: LuaTerm NameL -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
makeParam n :: LuaTerm NameL
n = CxtS NoHole MLuaSig (K ()) ParameterAttrsL
-> MLuaTerm IdentL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalParameter :-<: fs, All HFunctor fs) =>
CxtS h fs a ParameterAttrsL
-> CxtS h fs a IdentL -> CxtS h fs a FunctionParameterL
PositionalParameter' CxtS NoHole MLuaSig (K ()) ParameterAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyParameterAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a ParameterAttrsL
EmptyParameterAttrs' (LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm NameL
n)

splitLuaFunName :: F.LuaTerm F.FunNameL -> (MLuaTerm [IdentL], MLuaTerm IdentL, Bool)
splitLuaFunName :: LuaTerm FunNameL -> (MLuaTerm [IdentL], MLuaTerm IdentL, Bool)
splitLuaFunName (LuaTerm FunNameL -> Maybe (FunName LuaTerm FunNameL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunName n1 :: LuaTerm NameL
n1 n2s :: LuaTerm [NameL]
n2s n3opt :: Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
n3opt)) =
    case Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
n3opt of
      Just' n3 :: LuaTerm NameL
n3 -> ([MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([MLuaTerm IdentL] -> MLuaTerm [IdentL])
-> [MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall a b. (a -> b) -> a -> b
$ [MLuaTerm IdentL]
n1' [MLuaTerm IdentL] -> [MLuaTerm IdentL] -> [MLuaTerm IdentL]
forall a. [a] -> [a] -> [a]
++ [MLuaTerm IdentL]
n2s', LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm NameL
n3, Bool
True)
      Nothing' -> ([MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([MLuaTerm IdentL] -> MLuaTerm [IdentL])
-> [MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall a b. (a -> b) -> a -> b
$ [MLuaTerm IdentL] -> [MLuaTerm IdentL]
forall a. [a] -> [a]
init ([MLuaTerm IdentL]
n1' [MLuaTerm IdentL] -> [MLuaTerm IdentL] -> [MLuaTerm IdentL]
forall a. [a] -> [a] -> [a]
++ [MLuaTerm IdentL]
n2s'), [MLuaTerm IdentL] -> MLuaTerm IdentL
forall a. [a] -> a
last ([MLuaTerm IdentL]
n1' [MLuaTerm IdentL] -> [MLuaTerm IdentL] -> [MLuaTerm IdentL]
forall a. [a] -> [a] -> [a]
++ [MLuaTerm IdentL]
n2s'), Bool
False)
  where
    n1' :: [MLuaTerm IdentL]
n1'  = [LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm NameL
n1]
    n2s' :: [MLuaTerm IdentL]
n2s' = (LuaTerm NameL -> MLuaTerm IdentL)
-> [LuaTerm NameL] -> [MLuaTerm IdentL]
forall a b. (a -> b) -> [a] -> [b]
map LuaTerm NameL -> MLuaTerm IdentL
transIdent ([LuaTerm NameL] -> [MLuaTerm IdentL])
-> [LuaTerm NameL] -> [MLuaTerm IdentL]
forall a b. (a -> b) -> a -> b
$ LuaTerm [NameL] -> [LuaTerm NameL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF LuaTerm [NameL]
n2s

instance Trans F.Stat where
  trans :: Stat LuaTerm l -> MLuaTerm l
trans (F.Assign vs :: LuaTerm [VarL]
vs es :: LuaTerm [ExpL]
es) = CxtS NoHole MLuaSig (K ()) LhsL
-> CxtS NoHole MLuaSig (K ()) AssignOpL
-> CxtS NoHole MLuaSig (K ()) RhsL
-> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Assign :-<: fs, InjF fs AssignL j) =>
CxtS h fs a LhsL
-> CxtS h fs a AssignOpL -> CxtS h fs a RhsL -> CxtS h fs a j
iAssign (CxtS NoHole MLuaSig (K ()) [VarL]
-> CxtS NoHole MLuaSig (K ()) LhsL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) [VarL]
 -> CxtS NoHole MLuaSig (K ()) LhsL)
-> CxtS NoHole MLuaSig (K ()) [VarL]
-> CxtS NoHole MLuaSig (K ()) LhsL
forall a b. (a -> b) -> a -> b
$ LuaTerm [VarL] -> CxtS NoHole MLuaSig (K ()) [VarL]
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm [VarL]
vs) CxtS NoHole MLuaSig (K ()) AssignOpL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(AssignOpEquals :-<: fs, All HFunctor fs) =>
CxtS h fs a AssignOpL
AssignOpEquals' (CxtS NoHole MLuaSig (K ()) [ExpL]
-> CxtS NoHole MLuaSig (K ()) RhsL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) [ExpL]
 -> CxtS NoHole MLuaSig (K ()) RhsL)
-> CxtS NoHole MLuaSig (K ()) [ExpL]
-> CxtS NoHole MLuaSig (K ()) RhsL
forall a b. (a -> b) -> a -> b
$ LuaTerm [ExpL] -> CxtS NoHole MLuaSig (K ()) [ExpL]
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm [ExpL]
es)
  trans (F.LocalAssign vs :: LuaTerm [NameL]
vs init :: Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
init) = CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL -> MLuaTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL -> MLuaTerm l)
-> CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL -> MLuaTerm l
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) LocalVarDeclAttrsL
-> CxtS NoHole MLuaSig (K ()) VarDeclBinderL
-> CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
-> CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(SingleLocalVarDecl :-<: fs, All HFunctor fs) =>
CxtS h fs a LocalVarDeclAttrsL
-> CxtS h fs a VarDeclBinderL
-> CxtS h fs a OptLocalVarInitL
-> CxtS h fs a SingleLocalVarDeclL
SingleLocalVarDecl' CxtS NoHole MLuaSig (K ()) LocalVarDeclAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyLocalVarDeclAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a LocalVarDeclAttrsL
EmptyLocalVarDeclAttrs' (MLuaTerm [IdentL] -> CxtS NoHole MLuaSig (K ()) VarDeclBinderL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MLuaTerm [IdentL] -> CxtS NoHole MLuaSig (K ()) VarDeclBinderL)
-> MLuaTerm [IdentL] -> CxtS NoHole MLuaSig (K ()) VarDeclBinderL
forall a b. (a -> b) -> a -> b
$ (LuaTerm NameL -> MLuaTerm IdentL)
-> LuaTerm [NameL] -> MLuaTerm [IdentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm [NameL]
vs) CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
tInit
    where
      tInit :: CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
tInit = case Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
init of
        Just' x :: LuaTerm [ExpL]
x  -> CxtS NoHole MLuaSig (K ()) LocalVarInitL
-> CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(OptLocalVarInit :-<: fs, All HFunctor fs) =>
CxtS h fs a LocalVarInitL -> CxtS h fs a OptLocalVarInitL
JustLocalVarInit' (CxtS NoHole MLuaSig (K ()) LocalVarInitL
 -> CxtS NoHole MLuaSig (K ()) OptLocalVarInitL)
-> CxtS NoHole MLuaSig (K ()) LocalVarInitL
-> CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) [ExpL]
-> CxtS NoHole MLuaSig (K ()) LocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) [ExpL]
 -> CxtS NoHole MLuaSig (K ()) LocalVarInitL)
-> CxtS NoHole MLuaSig (K ()) [ExpL]
-> CxtS NoHole MLuaSig (K ()) LocalVarInitL
forall a b. (a -> b) -> a -> b
$ LuaTerm [ExpL] -> CxtS NoHole MLuaSig (K ()) [ExpL]
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm [ExpL]
x
        Nothing' -> CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(OptLocalVarInit :-<: fs, All HFunctor fs) =>
CxtS h fs a OptLocalVarInitL
NoLocalVarInit'
  trans (F.FunAssign fn :: LuaTerm FunNameL
fn (LuaTerm FunBodyL -> Maybe (FunBody LuaTerm FunBodyL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunBody pars :: LuaTerm [NameL]
pars varArg :: Bool
varArg body :: LuaTerm BlockL
body))) = CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
-> MLuaTerm IdentL
-> MLuaTerm [FunctionParameterL]
-> CxtS NoHole MLuaSig (K ()) FunctionBodyL
-> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionDef :-<: fs, InjF fs FunctionDefL j) =>
CxtS h fs a FunctionDefAttrsL
-> CxtS h fs a IdentL
-> CxtS h fs a [FunctionParameterL]
-> CxtS h fs a FunctionBodyL
-> CxtS h fs a j
iFunctionDef (CxtS NoHole MLuaSig (K ()) LuaFunctionDefinedObjL
-> CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaFunctionAttrs :-<: fs, InjF fs FunctionDefAttrsL j) =>
CxtS h fs a LuaFunctionDefinedObjL -> CxtS h fs a j
iLuaFunctionAttrs (CxtS NoHole MLuaSig (K ()) LuaFunctionDefinedObjL
 -> CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL)
-> CxtS NoHole MLuaSig (K ()) LuaFunctionDefinedObjL
-> CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
forall a b. (a -> b) -> a -> b
$ MLuaTerm [IdentL]
-> CxtS NoHole MLuaSig (K ()) LuaFunctionDefinedObjL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaFunctionDefinedObj :-<: fs,
 InjF fs LuaFunctionDefinedObjL j) =>
CxtS h fs a [IdentL] -> CxtS h fs a j
iLuaFunctionDefinedObj MLuaTerm [IdentL]
fnDefObjNms)
                                                                                       MLuaTerm IdentL
funNm
                                                                                       (MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
addReceiverParam (MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL])
-> MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
forall a b. (a -> b) -> a -> b
$ LuaTerm [NameL] -> Bool -> MLuaTerm [FunctionParameterL]
transParams LuaTerm [NameL]
pars Bool
varArg)
                                                                                       (MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL)
-> MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL
forall a b. (a -> b) -> a -> b
$ LuaTerm BlockL -> MLuaTerm BlockL
transBlock LuaTerm BlockL
body)
    where
      (fnDefObjNms :: MLuaTerm [IdentL]
fnDefObjNms, funNm :: MLuaTerm IdentL
funNm, isMethod :: Bool
isMethod) = LuaTerm FunNameL -> (MLuaTerm [IdentL], MLuaTerm IdentL, Bool)
splitLuaFunName LuaTerm FunNameL
fn

      addReceiverParam :: MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
      addReceiverParam :: MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
addReceiverParam x :: MLuaTerm [FunctionParameterL]
x = if Bool
isMethod then Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
-> MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(ListF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l]
ConsF' Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(SelfParameter :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionParameterL
SelfParameter' MLuaTerm [FunctionParameterL]
x else MLuaTerm [FunctionParameterL]
x

  trans (F.LocalFunAssign n :: LuaTerm NameL
n (LuaTerm FunBodyL -> Maybe (FunBody LuaTerm FunBodyL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunBody pars :: LuaTerm [NameL]
pars varArg :: Bool
varArg body :: LuaTerm BlockL
body))) = CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
-> MLuaTerm IdentL
-> MLuaTerm [FunctionParameterL]
-> CxtS NoHole MLuaSig (K ()) FunctionBodyL
-> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionDef :-<: fs, InjF fs FunctionDefL j) =>
CxtS h fs a FunctionDefAttrsL
-> CxtS h fs a IdentL
-> CxtS h fs a [FunctionParameterL]
-> CxtS h fs a FunctionBodyL
-> CxtS h fs a j
iFunctionDef CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionDefAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionDefAttrsL
EmptyFunctionDefAttrs' (LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm NameL
n) (LuaTerm [NameL] -> Bool -> MLuaTerm [FunctionParameterL]
transParams LuaTerm [NameL]
pars Bool
varArg) (MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL)
-> MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) FunctionBodyL
forall a b. (a -> b) -> a -> b
$ LuaTerm BlockL -> MLuaTerm BlockL
transBlock LuaTerm BlockL
body)
  trans x :: Stat LuaTerm l
x = Stat LuaTerm l -> MLuaTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MLuaSig, f :-<: LuaSig) =>
f LuaTerm l -> MLuaTerm l
transDefault Stat LuaTerm l
x


translateFunArg :: F.LuaTerm F.FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg :: LuaTerm FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Args args :: LuaTerm [ExpL]
args))   = CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
-> MLuaTerm FunctionArgumentsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(FunctionArgumentList :-<: fs, All HFunctor fs) =>
CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL
FunctionArgumentList' ((Cxt NoHole (Sum LuaSig) (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> LuaTerm [ExpL] -> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF (CxtS NoHole MLuaSig (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalArgument :-<: fs, All HFunctor fs) =>
CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL
PositionalArgument' (CxtS NoHole MLuaSig (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) PositionalArgExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) PositionalArgExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) PositionalArgExpL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) ExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) PositionalArgExpL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate) LuaTerm [ExpL]
args)
translateFunArg (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.TableArg t :: Cxt NoHole (Sum LuaSig) (K ()) TableL
t))  = CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaSpecialFunArg :-<: fs, InjF fs FunctionArgumentsL j) =>
CxtS h fs a TableL -> CxtS h fs a j
iLuaTableArg (CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL)
-> CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) TableL
-> CxtS NoHole MLuaSig (K ()) TableL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate Cxt NoHole (Sum LuaSig) (K ()) TableL
t
translateFunArg (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.StringArg s :: Text
s)) = String -> MLuaTerm FunctionArgumentsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaSpecialFunArg :-<: fs, InjF fs FunctionArgumentsL j) =>
String -> CxtS h fs a j
iLuaStringArg (String -> MLuaTerm FunctionArgumentsL)
-> String -> MLuaTerm FunctionArgumentsL
forall a b. (a -> b) -> a -> b
$ Text -> String
unpack Text
s

instance Trans F.FunCall where
  trans :: FunCall LuaTerm l -> MLuaTerm l
trans (F.NormalFunCall  f :: LuaTerm PrefixExpL
f arg :: LuaTerm FunArgL
arg) = CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
-> MLuaTerm FunctionArgumentsL
-> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionCall :-<: fs, InjF fs FunctionCallL j) =>
CxtS h fs a FunctionCallAttrsL
-> CxtS h fs a FunctionExpL
-> CxtS h fs a FunctionArgumentsL
-> CxtS h fs a j
iFunctionCall CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionCallAttrsL
EmptyFunctionCallAttrs' (CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) PrefixExpL
 -> CxtS NoHole MLuaSig (K ()) FunctionExpL)
-> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall a b. (a -> b) -> a -> b
$ LuaTerm PrefixExpL -> CxtS NoHole MLuaSig (K ()) PrefixExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm PrefixExpL
f) (LuaTerm FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg LuaTerm FunArgL
arg)
  trans (F.MethodCall rec :: LuaTerm PrefixExpL
rec f :: LuaTerm NameL
f arg :: LuaTerm FunArgL
arg) = CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
-> MLuaTerm FunctionArgumentsL
-> MLuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunctionCall :-<: fs, InjF fs FunctionCallL j) =>
CxtS h fs a FunctionCallAttrsL
-> CxtS h fs a FunctionExpL
-> CxtS h fs a FunctionArgumentsL
-> CxtS h fs a j
iFunctionCall CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionCallAttrsL
EmptyFunctionCallAttrs' (MLuaTerm IdentL -> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MLuaTerm IdentL -> CxtS NoHole MLuaSig (K ()) FunctionExpL)
-> MLuaTerm IdentL -> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall a b. (a -> b) -> a -> b
$ LuaTerm NameL -> MLuaTerm IdentL
transIdent LuaTerm NameL
f) MLuaTerm FunctionArgumentsL
receiverArg
    where
      receiverArg :: MLuaTerm FunctionArgumentsL
      receiverArg :: MLuaTerm FunctionArgumentsL
receiverArg = case LuaTerm FunArgL
arg of
                      (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Args as :: LuaTerm [ExpL]
as)) -> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
-> MLuaTerm FunctionArgumentsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(FunctionArgumentList :-<: fs, All HFunctor fs) =>
CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL
FunctionArgumentList' (Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
-> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
-> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(ListF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a [l] -> Cxt h f a [l]
ConsF' (CxtS NoHole MLuaSig (K ()) ReceiverL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(ReceiverArg :-<: fs, All HFunctor fs) =>
CxtS h fs a ReceiverL -> CxtS h fs a FunctionArgumentL
ReceiverArg' (CxtS NoHole MLuaSig (K ()) ReceiverL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> CxtS NoHole MLuaSig (K ()) ReceiverL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) ReceiverL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) PrefixExpL
 -> CxtS NoHole MLuaSig (K ()) ReceiverL)
-> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) ReceiverL
forall a b. (a -> b) -> a -> b
$ LuaTerm PrefixExpL -> CxtS NoHole MLuaSig (K ()) PrefixExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm PrefixExpL
rec)
                                                                                      ((Cxt NoHole (Sum LuaSig) (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> LuaTerm [ExpL] -> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF (CxtS NoHole MLuaSig (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalArgument :-<: fs, All HFunctor fs) =>
CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL
PositionalArgument' (CxtS NoHole MLuaSig (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) PositionalArgExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) PositionalArgExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) PositionalArgExpL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) ExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) PositionalArgExpL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate) LuaTerm [ExpL]
as))
                      (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.TableArg  t :: Cxt NoHole (Sum LuaSig) (K ()) TableL
t)) -> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaSpecialFunArg :-<: fs, InjF fs FunctionArgumentsL j) =>
CxtS h fs a PrefixExpL -> CxtS h fs a TableL -> CxtS h fs a j
iLuaReceiverAndTableArg  (LuaTerm PrefixExpL -> CxtS NoHole MLuaSig (K ()) PrefixExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm PrefixExpL
rec) (Cxt NoHole (Sum LuaSig) (K ()) TableL
-> CxtS NoHole MLuaSig (K ()) TableL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate Cxt NoHole (Sum LuaSig) (K ()) TableL
t)
                      (LuaTerm FunArgL -> Maybe (FunArg LuaTerm FunArgL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.StringArg s :: Text
s)) -> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> String -> MLuaTerm FunctionArgumentsL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(LuaSpecialFunArg :-<: fs, InjF fs FunctionArgumentsL j) =>
CxtS h fs a PrefixExpL -> String -> CxtS h fs a j
iLuaReceiverAndStringArg (LuaTerm PrefixExpL -> CxtS NoHole MLuaSig (K ()) PrefixExpL
LuaTerm :-> Cxt NoHole (Sum MLuaSig) (K ())
translate LuaTerm PrefixExpL
rec) (Text -> String
unpack Text
s)

instance Trans F.FunArg where
  trans :: FunArg LuaTerm l -> MLuaTerm l
trans _ = String -> MLuaTerm l
forall a. HasCallStack => String -> a
error "Lua FunArg found not with FunCall"

untranslate :: MLuaTerm l -> F.LuaTerm l
untranslate :: MLuaTerm l -> LuaTerm l
untranslate = Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
forall (f :: (* -> *) -> * -> *) l.
Untrans f =>
f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l)
-> (MLuaTerm l -> Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l)
-> MLuaTerm l
-> LuaTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MLuaTerm l -> Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l
forall (f :: (* -> *) -> * -> *) t. HFix f t -> f (HFix f) t
unTerm

class Untrans f where
  untrans :: f MLuaTerm l -> F.LuaTerm l

instance {-# OVERLAPPING #-} (All Untrans fs) => Untrans (Sum fs) where
  untrans :: Sum fs (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans = Proxy Untrans
-> (forall (f :: (* -> *) -> * -> *).
    Untrans f =>
    f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l)
-> Sum fs (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
forall (cxt :: ((* -> *) -> * -> *) -> Constraint)
       (fs :: [(* -> *) -> * -> *]) (a :: * -> *) e b.
All cxt fs =>
Proxy cxt
-> (forall (f :: (* -> *) -> * -> *). cxt f => f a e -> b)
-> Sum fs a e
-> b
caseCxt (Proxy Untrans
forall k (t :: k). Proxy t
Proxy @Untrans) forall (f :: (* -> *) -> * -> *).
Untrans f =>
f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
forall (f :: (* -> *) -> * -> *) l.
Untrans f =>
f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans

untransDefault :: (HFunctor f, f :-<: F.LuaSig) => f MLuaTerm l -> F.LuaTerm l
untransDefault :: f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untransDefault = f LuaTerm l -> LuaTerm l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f LuaTerm l -> LuaTerm l)
-> (f (Cxt NoHole (Sum MLuaSig) (K ())) l -> f LuaTerm l)
-> f (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm)
-> f (Cxt NoHole (Sum MLuaSig) (K ())) :-> f LuaTerm
forall (h :: (* -> *) -> * -> *) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: F.LuaSig) => Untrans f where
  untrans :: f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans = f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: LuaSig) =>
f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untransDefault

untransIdent :: MLuaTerm IdentL -> F.LuaTerm F.NameL
untransIdent :: MLuaTerm IdentL -> LuaTerm NameL
untransIdent (Ident' n :: String
n) = Text -> LuaTerm NameL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Name :-<: fs, InjF fs NameL j) =>
Text -> CxtS h fs a j
F.iName (Text -> LuaTerm NameL) -> Text -> LuaTerm NameL
forall a b. (a -> b) -> a -> b
$ String -> Text
pack String
n

instance {-# OVERLAPPING #-} Untrans IdentIsName where
  untrans :: IdentIsName (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (IdentIsName (Ident' n :: String
n)) = Text -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Name :-<: fs, InjF fs NameL j) =>
Text -> CxtS h fs a j
F.iName (Text -> LuaTerm l) -> Text -> LuaTerm l
forall a b. (a -> b) -> a -> b
$ String -> Text
pack String
n

instance {-# OVERLAPPING #-} Untrans AssignIsStat where
  untrans :: AssignIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (AssignIsStat (Assign' l :: CxtS NoHole MLuaSig (K ()) LhsL
l _ r :: CxtS NoHole MLuaSig (K ()) RhsL
r)) = LuaTerm [VarL] -> LuaTerm [ExpL] -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Stat :-<: fs, InjF fs StatL j) =>
CxtS h fs a [VarL] -> CxtS h fs a [ExpL] -> CxtS h fs a j
F.iAssign (CxtS NoHole MLuaSig (K ()) [VarL] -> LuaTerm [VarL]
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (CxtS NoHole MLuaSig (K ()) [VarL] -> LuaTerm [VarL])
-> CxtS NoHole MLuaSig (K ()) [VarL] -> LuaTerm [VarL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) LhsL
-> CxtS NoHole MLuaSig (K ()) [VarL]
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) LhsL
l) (CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL]
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL])
-> CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) RhsL
-> CxtS NoHole MLuaSig (K ()) [ExpL]
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) RhsL
r)

instance {-# OVERLAPPING #-} Untrans SingleLocalVarDeclIsStat where
  untrans :: SingleLocalVarDeclIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
untrans (SingleLocalVarDeclIsStat (SingleLocalVarDecl' _ b :: CxtS NoHole MLuaSig (K ()) VarDeclBinderL
b init :: CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
init)) = LuaTerm [NameL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL]) -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Stat :-<: fs, InjF fs StatL j) =>
CxtS h fs a [NameL] -> CxtS h fs a (Maybe [ExpL]) -> CxtS h fs a j
F.iLocalAssign ((MLuaTerm IdentL -> LuaTerm NameL)
-> MLuaTerm [IdentL] -> LuaTerm [NameL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF MLuaTerm IdentL -> LuaTerm NameL
untransIdent (MLuaTerm [IdentL] -> LuaTerm [NameL])
-> MLuaTerm [IdentL] -> LuaTerm [NameL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) VarDeclBinderL -> MLuaTerm [IdentL]
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) VarDeclBinderL
b) Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
linit
    where
      linit :: Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
linit = case CxtS NoHole MLuaSig (K ()) OptLocalVarInitL
init of
        NoLocalVarInit'     -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing'
        JustLocalVarInit' x :: CxtS NoHole MLuaSig (K ()) LocalVarInitL
x -> LuaTerm [ExpL] -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (LuaTerm [ExpL] -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL]))
-> LuaTerm [ExpL] -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL]
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL])
-> CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) LocalVarInitL
-> CxtS NoHole MLuaSig (K ()) [ExpL]
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) LocalVarInitL
x

untransBlock :: MLuaTerm BlockL -> F.LuaTerm F.BlockL
untransBlock :: MLuaTerm BlockL -> LuaTerm BlockL
untransBlock (Block' n :: CxtS NoHole MLuaSig (K ()) [BlockItemL]
n e :: CxtS NoHole MLuaSig (K ()) BlockEndL
e) = Cxt NoHole (Sum LuaSig) (K ()) [StatL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL]) -> LuaTerm BlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Block :-<: fs, InjF fs BlockL j) =>
CxtS h fs a [StatL] -> CxtS h fs a (Maybe [ExpL]) -> CxtS h fs a j
F.iBlock ((Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
 -> Cxt NoHole (Sum LuaSig) (K ()) StatL)
-> CxtS NoHole MLuaSig (K ()) [BlockItemL]
-> Cxt NoHole (Sum LuaSig) (K ()) [StatL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF (CxtS NoHole MLuaSig (K ()) StatL
-> Cxt NoHole (Sum LuaSig) (K ()) StatL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate(CxtS NoHole MLuaSig (K ()) StatL
 -> Cxt NoHole (Sum LuaSig) (K ()) StatL)
-> (Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
    -> CxtS NoHole MLuaSig (K ()) StatL)
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
-> Cxt NoHole (Sum LuaSig) (K ()) StatL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL
-> CxtS NoHole MLuaSig (K ()) StatL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF) CxtS NoHole MLuaSig (K ()) [BlockItemL]
n) (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
 -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL]))
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) BlockEndL
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) BlockEndL
e)

instance {-# OVERLAPPING #-} Untrans BlockIsBlock where
  untrans :: BlockIsBlock (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (BlockIsBlock b :: MLuaTerm BlockL
b) = MLuaTerm BlockL -> LuaTerm BlockL
untransBlock MLuaTerm BlockL
b


-- This thing could probably be blown down a lot, but I was tired and didn't want to figure
-- out the correlation between cases
instance {-# OVERLAPPING #-} Untrans FunctionCallIsFunCall where
  untrans :: FunctionCallIsFunCall (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
untrans (FunctionCallIsFunCall (FunctionCall' EmptyFunctionCallAttrs' f :: CxtS NoHole MLuaSig (K ()) FunctionExpL
f args :: MLuaTerm FunctionArgumentsL
args)) =
      case Maybe (LuaTerm PrefixExpL)
receiver of
        Nothing -> LuaTerm PrefixExpL -> LuaTerm FunArgL -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunCall :-<: fs, InjF fs FunCallL j) =>
CxtS h fs a PrefixExpL -> CxtS h fs a FunArgL -> CxtS h fs a j
F.iNormalFunCall (Maybe (LuaTerm PrefixExpL) -> LuaTerm PrefixExpL
forall a. HasCallStack => Maybe a -> a
fromJust Maybe (LuaTerm PrefixExpL)
fun) LuaTerm FunArgL
fa
        Just r :: LuaTerm PrefixExpL
r  -> LuaTerm PrefixExpL -> LuaTerm NameL -> LuaTerm FunArgL -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunCall :-<: fs, InjF fs FunCallL j) =>
CxtS h fs a PrefixExpL
-> CxtS h fs a NameL -> CxtS h fs a FunArgL -> CxtS h fs a j
F.iMethodCall (Maybe (LuaTerm PrefixExpL) -> LuaTerm PrefixExpL
forall a. HasCallStack => Maybe a -> a
fromJust Maybe (LuaTerm PrefixExpL)
receiver) (Maybe (LuaTerm NameL) -> LuaTerm NameL
forall a. HasCallStack => Maybe a -> a
fromJust Maybe (LuaTerm NameL)
funNm) LuaTerm FunArgL
fa
    where
      fun :: Maybe (F.LuaTerm F.PrefixExpL)
      fun :: Maybe (LuaTerm PrefixExpL)
fun = case CxtS NoHole MLuaSig (K ()) FunctionExpL
-> Maybe
     (PrefixExpIsFunctionExp
        (Cxt NoHole (Sum MLuaSig) (K ())) FunctionExpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project CxtS NoHole MLuaSig (K ()) FunctionExpL
f of
              Just (PrefixExpIsFunctionExp x :: CxtS NoHole MLuaSig (K ()) PrefixExpL
x) -> LuaTerm PrefixExpL -> Maybe (LuaTerm PrefixExpL)
forall a. a -> Maybe a
Just (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
x)
              _                               -> Maybe (LuaTerm PrefixExpL)
forall a. Maybe a
Nothing

      funNm :: Maybe (F.LuaTerm F.NameL)
      funNm :: Maybe (LuaTerm NameL)
funNm = case CxtS NoHole MLuaSig (K ()) FunctionExpL
-> Maybe
     (FunctionIdent (Cxt NoHole (Sum MLuaSig) (K ())) FunctionExpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project CxtS NoHole MLuaSig (K ()) FunctionExpL
f of
              Just (FunctionIdent i :: MLuaTerm IdentL
i) -> LuaTerm NameL -> Maybe (LuaTerm NameL)
forall a. a -> Maybe a
Just (MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
i)
              _                      -> Maybe (LuaTerm NameL)
forall a. Maybe a
Nothing

      receiver :: Maybe (F.LuaTerm F.PrefixExpL)
      receiver :: Maybe (LuaTerm PrefixExpL)
receiver = case MLuaTerm FunctionArgumentsL
args of
                   FunctionArgumentList' (ConsF' (ReceiverArg' r :: CxtS NoHole MLuaSig (K ()) ReceiverL
r) _) -> (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL)
-> Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
-> Maybe (LuaTerm PrefixExpL)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
 -> Maybe (LuaTerm PrefixExpL))
-> Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
-> Maybe (LuaTerm PrefixExpL)
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) ReceiverL
-> Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> Maybe (CxtS h fs a l)
projF CxtS NoHole MLuaSig (K ()) ReceiverL
r
                   _     -> case MLuaTerm FunctionArgumentsL
-> Maybe
     (LuaSpecialFunArg
        (Cxt NoHole (Sum MLuaSig) (K ())) FunctionArgumentsL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project MLuaTerm FunctionArgumentsL
args of
                                Just (LuaReceiverAndTableArg  rec :: CxtS NoHole MLuaSig (K ()) PrefixExpL
rec _) -> LuaTerm PrefixExpL -> Maybe (LuaTerm PrefixExpL)
forall a. a -> Maybe a
Just (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
rec)
                                Just (LuaReceiverAndStringArg rec :: CxtS NoHole MLuaSig (K ()) PrefixExpL
rec _) -> LuaTerm PrefixExpL -> Maybe (LuaTerm PrefixExpL)
forall a. a -> Maybe a
Just (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
rec)
                                _                                    -> Maybe (LuaTerm PrefixExpL)
forall a. Maybe a
Nothing

      untransArgs :: MLuaTerm [FunctionArgumentL] -> F.LuaTerm [F.ExpL]
      untransArgs :: CxtS NoHole MLuaSig (K ()) [FunctionArgumentL] -> LuaTerm [ExpL]
untransArgs = (Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
 -> Cxt NoHole (Sum LuaSig) (K ()) ExpL)
-> CxtS NoHole MLuaSig (K ()) [FunctionArgumentL] -> LuaTerm [ExpL]
forall (f :: * -> *) (h :: * -> *) (g :: * -> *) b a.
(InsertF f h, ExtractF f g, Functor f, Typeable b) =>
(g a -> h b) -> g (f a) -> h (f b)
mapF Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
forall l.
InjF MLuaSig l PositionalArgExpL =>
Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL -> LuaTerm l
untransArg
        where
          untransArg :: Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL -> LuaTerm l
untransArg (PositionalArgument' p :: CxtS NoHole MLuaSig (K ()) PositionalArgExpL
p) = MLuaTerm l -> LuaTerm l
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate (MLuaTerm l -> LuaTerm l) -> MLuaTerm l -> LuaTerm l
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) PositionalArgExpL -> MLuaTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) PositionalArgExpL
p

      fa :: F.LuaTerm F.FunArgL
      fa :: LuaTerm FunArgL
fa = case MLuaTerm FunctionArgumentsL
args of
             FunctionArgumentList' (ConsF' (ReceiverArg' _) as :: CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
as) -> LuaTerm [ExpL] -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a [ExpL] -> CxtS h fs a j
F.iArgs (CxtS NoHole MLuaSig (K ()) [FunctionArgumentL] -> LuaTerm [ExpL]
untransArgs CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
as)
             FunctionArgumentList' as :: CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
as                           -> LuaTerm [ExpL] -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a [ExpL] -> CxtS h fs a j
F.iArgs (CxtS NoHole MLuaSig (K ()) [FunctionArgumentL] -> LuaTerm [ExpL]
untransArgs CxtS NoHole MLuaSig (K ()) [FunctionArgumentL]
as)
             _      -> case MLuaTerm FunctionArgumentsL
-> Maybe
     (LuaSpecialFunArg
        (Cxt NoHole (Sum MLuaSig) (K ())) FunctionArgumentsL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project MLuaTerm FunctionArgumentsL
args of
                          Just (LuaTableArg               x :: CxtS NoHole MLuaSig (K ()) TableL
x) -> Cxt NoHole (Sum LuaSig) (K ()) TableL -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a TableL -> CxtS h fs a j
F.iTableArg  (CxtS NoHole MLuaSig (K ()) TableL
-> Cxt NoHole (Sum LuaSig) (K ()) TableL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate CxtS NoHole MLuaSig (K ()) TableL
x)
                          Just (LuaStringArg              s :: String
s) -> Text -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
Text -> CxtS h fs a j
F.iStringArg (String -> Text
pack String
s)
                          Just (LuaReceiverAndTableArg  _ x :: CxtS NoHole MLuaSig (K ()) TableL
x) -> Cxt NoHole (Sum LuaSig) (K ()) TableL -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a TableL -> CxtS h fs a j
F.iTableArg  (CxtS NoHole MLuaSig (K ()) TableL
-> Cxt NoHole (Sum LuaSig) (K ()) TableL
Cxt NoHole (Sum MLuaSig) (K ()) :-> LuaTerm
untranslate CxtS NoHole MLuaSig (K ()) TableL
x)
                          Just (LuaReceiverAndStringArg _ s :: String
s) -> Text -> LuaTerm FunArgL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
Text -> CxtS h fs a j
F.iStringArg (String -> Text
pack String
s)

instance {-# OVERLAPPING #-} Untrans FunctionDefIsStat where
  untrans :: FunctionDefIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (FunctionDefIsStat (FunctionDef' attrs :: CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
attrs n :: MLuaTerm IdentL
n params :: MLuaTerm [FunctionParameterL]
params body :: CxtS NoHole MLuaSig (K ()) FunctionBodyL
body)) =
      case CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
attrs of
        EmptyFunctionDefAttrs'-> LuaTerm NameL -> LuaTerm FunBodyL -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Stat :-<: fs, InjF fs StatL j) =>
CxtS h fs a NameL -> CxtS h fs a FunBodyL -> CxtS h fs a j
F.iLocalFunAssign (MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
n) (LuaTerm [NameL] -> Bool -> LuaTerm BlockL -> LuaTerm FunBodyL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunBody :-<: fs, InjF fs FunBodyL j) =>
CxtS h fs a [NameL] -> Bool -> CxtS h fs a BlockL -> CxtS h fs a j
F.iFunBody LuaTerm [NameL]
params'' Bool
isVarargs (MLuaTerm BlockL -> LuaTerm BlockL
untransBlock (MLuaTerm BlockL -> LuaTerm BlockL)
-> MLuaTerm BlockL -> LuaTerm BlockL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) FunctionBodyL -> MLuaTerm BlockL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) FunctionBodyL
body))
        (LuaFunctionAttrs' (LuaFunctionDefinedObj' nms :: MLuaTerm [IdentL]
nms)) -> LuaTerm FunNameL -> LuaTerm FunBodyL -> LuaTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Stat :-<: fs, InjF fs StatL j) =>
CxtS h fs a FunNameL -> CxtS h fs a FunBodyL -> CxtS h fs a j
F.iFunAssign ([MLuaTerm IdentL] -> LuaTerm FunNameL
congealFunName ([MLuaTerm IdentL] -> LuaTerm FunNameL)
-> [MLuaTerm IdentL] -> LuaTerm FunNameL
forall a b. (a -> b) -> a -> b
$ MLuaTerm [IdentL] -> [MLuaTerm IdentL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF MLuaTerm [IdentL]
nms) (LuaTerm [NameL] -> Bool -> LuaTerm BlockL -> LuaTerm FunBodyL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunBody :-<: fs, InjF fs FunBodyL j) =>
CxtS h fs a [NameL] -> Bool -> CxtS h fs a BlockL -> CxtS h fs a j
F.iFunBody LuaTerm [NameL]
params'' Bool
isVarargs (MLuaTerm BlockL -> LuaTerm BlockL
untransBlock (MLuaTerm BlockL -> LuaTerm BlockL)
-> MLuaTerm BlockL -> LuaTerm BlockL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) FunctionBodyL -> MLuaTerm BlockL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MLuaSig (K ()) FunctionBodyL
body))
    where
      paramsList :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList = MLuaTerm [FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF MLuaTerm [FunctionParameterL]
params
      (params' :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
params', isVarargs :: Bool
isVarargs) = if [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0 then
                               case [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall a. [a] -> a
last [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList of
                                 LuaVarArgsParam' -> ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a. [a] -> [a]
init [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList, Bool
True)
                                 _                -> ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList,      Bool
False)
                             else
                               ([], Bool
False)

      params'' :: LuaTerm [NameL]
params'' = [LuaTerm NameL] -> LuaTerm [NameL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([LuaTerm NameL] -> LuaTerm [NameL])
-> [LuaTerm NameL] -> LuaTerm [NameL]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
 -> LuaTerm NameL)
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [LuaTerm NameL]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL -> LuaTerm NameL
unwrapParam ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
 -> [LuaTerm NameL])
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [LuaTerm NameL]
forall a b. (a -> b) -> a -> b
$ [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
removeSelf [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
params'
        where
          unwrapParam :: MLuaTerm FunctionParameterL -> F.LuaTerm F.NameL
          unwrapParam :: Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL -> LuaTerm NameL
unwrapParam (PositionalParameter' EmptyParameterAttrs' n :: MLuaTerm IdentL
n) = MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
n

      hasSelf :: [MLuaTerm FunctionParameterL] -> Bool
      hasSelf :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL] -> Bool
hasSelf (SelfParameter' : l :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l) = Bool
True
      hasSelf l :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l                    = Bool
False

      congealFunName :: [MLuaTerm IdentL] -> F.LuaTerm F.FunNameL
      congealFunName :: [MLuaTerm IdentL] -> LuaTerm FunNameL
congealFunName nms :: [MLuaTerm IdentL]
nms = if [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL] -> Bool
hasSelf [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
params' then
                             LuaTerm NameL
-> LuaTerm [NameL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
-> LuaTerm FunNameL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunName :-<: fs, InjF fs FunNameL j) =>
CxtS h fs a NameL
-> CxtS h fs a [NameL]
-> CxtS h fs a (Maybe NameL)
-> CxtS h fs a j
F.iFunName ([LuaTerm NameL] -> LuaTerm NameL
forall a. [a] -> a
head [LuaTerm NameL]
nms') ([LuaTerm NameL] -> LuaTerm [NameL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([LuaTerm NameL] -> LuaTerm [NameL])
-> [LuaTerm NameL] -> LuaTerm [NameL]
forall a b. (a -> b) -> a -> b
$ [LuaTerm NameL] -> [LuaTerm NameL]
forall a. [a] -> [a]
tail [LuaTerm NameL]
nms') (LuaTerm NameL -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' LuaTerm NameL
n')
                           else
                             -- "drop 1" is a safe version of tail
                             LuaTerm NameL
-> LuaTerm [NameL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
-> LuaTerm FunNameL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(FunName :-<: fs, InjF fs FunNameL j) =>
CxtS h fs a NameL
-> CxtS h fs a [NameL]
-> CxtS h fs a (Maybe NameL)
-> CxtS h fs a j
F.iFunName ([LuaTerm NameL] -> LuaTerm NameL
forall a. [a] -> a
head ([LuaTerm NameL]
nms' [LuaTerm NameL] -> [LuaTerm NameL] -> [LuaTerm NameL]
forall a. [a] -> [a] -> [a]
++ [LuaTerm NameL
n'])) ([LuaTerm NameL] -> LuaTerm [NameL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([LuaTerm NameL] -> LuaTerm [NameL])
-> [LuaTerm NameL] -> LuaTerm [NameL]
forall a b. (a -> b) -> a -> b
$ Int -> [LuaTerm NameL] -> [LuaTerm NameL]
forall a. Int -> [a] -> [a]
drop 1 ([LuaTerm NameL]
nms' [LuaTerm NameL] -> [LuaTerm NameL] -> [LuaTerm NameL]
forall a. [a] -> [a] -> [a]
++ [LuaTerm NameL
n'])) Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing'
        where
          nms' :: [LuaTerm NameL]
nms' = (MLuaTerm IdentL -> LuaTerm NameL)
-> [MLuaTerm IdentL] -> [LuaTerm NameL]
forall a b. (a -> b) -> [a] -> [b]
map MLuaTerm IdentL -> LuaTerm NameL
untransIdent [MLuaTerm IdentL]
nms
          n' :: LuaTerm NameL
n' = MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
n


      removeSelf :: [MLuaTerm FunctionParameterL] -> [MLuaTerm FunctionParameterL]
      removeSelf :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
removeSelf l :: [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l | [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL] -> Bool
hasSelf [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l = [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a. [a] -> [a]
tail  [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l
                   | Bool
otherwise = [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l


untransError :: (HFunctor f, f :-<: MLuaSig) => f MLuaTerm l -> F.LuaTerm l
untransError :: f (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untransError t :: f (Cxt NoHole (Sum MLuaSig) (K ())) l
t = String -> LuaTerm l
forall a. HasCallStack => String -> a
error (String -> LuaTerm l) -> String -> LuaTerm l
forall a b. (a -> b) -> a -> b
$ "Cannot untranslate root node: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (MLuaTerm l -> String
forall a. Show a => a -> String
show (MLuaTerm l -> String) -> MLuaTerm l -> String
forall a b. (a -> b) -> a -> b
$ (f (Cxt NoHole (Sum MLuaSig) (K ())) l -> MLuaTerm l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject f (Cxt NoHole (Sum MLuaSig) (K ())) l
t :: MLuaTerm _))

do ipsNames <- sumToNames ''MLuaSig
   modNames <- sumToNames ''F.LuaSig
   let targTs = map ConT $ (ipsNames \\ modNames) \\ [''BlockIsBlock, ''SingleLocalVarDeclIsStat, ''AssignIsStat, ''IdentIsName, ''FunctionCallIsFunCall, ''FunctionDefIsStat]
   return $ makeDefaultInstances targTs ''Untrans 'untrans (VarE 'untransError)