{-# OPTIONS_HADDOCK hide #-}

{-# LANGUAGE PartialTypeSignatures    #-}
{-# LANGUAGE TemplateHaskell          #-}
{-# 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.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 :: forall l. LuaTerm l -> MLuaTerm l
translate = Sum LuaSig (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall l.
Sum LuaSig (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall (f :: Fragment) l.
Trans f =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans (Sum LuaSig (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l)
-> (LuaTerm l -> Sum LuaSig (Cxt NoHole (Sum LuaSig) (K ())) l)
-> LuaTerm l
-> MLuaTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LuaTerm l -> Sum LuaSig (Cxt NoHole (Sum LuaSig) (K ())) l
forall (f :: Fragment) 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 :: forall l. Sum fs (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans = forall (cxt :: Fragment -> Constraint) (fs :: [Fragment])
       (a :: * -> *) e b.
All cxt fs =>
(forall (f :: Fragment). cxt f => f a e -> b) -> Sum fs a e -> b
caseCxt @Trans f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall l. f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall (f :: Fragment).
Trans f =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall (f :: Fragment) l.
Trans f =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans

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

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: MLuaSig, f :-<: F.LuaSig) => Trans f where
  trans :: forall l. f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans = f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
forall (f :: Fragment) l.
(HFunctor f, f :-<: MLuaSig, f :-<: LuaSig) =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
transDefault

transIdent :: F.LuaTerm F.NameL -> MLuaTerm IdentL
transIdent :: LuaTerm NameL -> MLuaTerm IdentL
transIdent (LuaTerm NameL
-> Maybe (Name (Cxt NoHole (Sum LuaSig) (K ())) NameL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (Name (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Name Text
n)) = String -> MLuaTerm IdentL
forall h (f :: Fragment) (a :: * -> *) j.
(Ident :<: f) =>
String -> Cxt h f 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 (Cxt NoHole (Sum LuaSig) (K ())) BlockL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (Block (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Block Cxt NoHole (Sum LuaSig) (K ()) [StatL]
s Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
e)) = Cxt NoHole (Sum MLuaSig) (K ()) [BlockItemL]
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL -> MLuaTerm BlockL
forall h (f :: Fragment) (a :: * -> *) j.
(Block :<: f) =>
Cxt h f a [BlockItemL] -> Cxt h f a BlockEndL -> Cxt h f a BlockL
Block' ((Cxt NoHole (Sum LuaSig) (K ()) StatL
 -> Cxt NoHole (Sum MLuaSig) (K ()) BlockItemL)
-> Cxt NoHole (Sum LuaSig) (K ()) [StatL]
-> Cxt NoHole (Sum 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 :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a StatL -> CxtS h MLuaSig a BlockItemL
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
forall l. LuaTerm l -> MLuaTerm l
translate) Cxt NoHole (Sum LuaSig) (K ()) [StatL]
s) (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a (Maybe [ExpL]) -> CxtS h MLuaSig a BlockEndL
injF (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
 -> Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL)
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
e)

instance Trans F.Block where
  trans :: forall l. Block (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans b :: Block (Cxt NoHole (Sum LuaSig) (K ())) l
b@(F.Block Cxt NoHole (Sum LuaSig) (K ()) [StatL]
_ Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
_) = MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) l
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a BlockL -> CxtS h MLuaSig a l
injF (MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) l)
-> MLuaTerm BlockL -> CxtS NoHole MLuaSig (K ()) 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 (Cxt NoHole (Sum LuaSig) (K ())) BlockL -> LuaTerm BlockL
Block (Cxt NoHole (Sum LuaSig) (K ()))
:-> Cxt NoHole (Sum LuaSig) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject Block (Cxt NoHole (Sum LuaSig) (K ())) l
Block (Cxt NoHole (Sum LuaSig) (K ())) BlockL
b

instance Trans F.Name where
  trans :: forall l. Name (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans (F.Name Text
n) = String -> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
iIdent (String -> CxtS NoHole MLuaSig (K ()) l)
-> String -> CxtS NoHole MLuaSig (K ()) 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 LuaTerm [NameL]
nms Bool
varArg = [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> MLuaTerm [FunctionParameterL]
forall l.
Typeable l =>
[Cxt NoHole (Sum MLuaSig) (K ()) l]
-> Cxt NoHole (Sum MLuaSig) (K ()) [l]
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 l.
Cxt NoHole (Sum LuaSig) (K ()) [l]
-> [Cxt NoHole (Sum LuaSig) (K ()) l]
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 :: [Fragment]) (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 LuaTerm NameL
n = Cxt NoHole (Sum MLuaSig) (K ()) ParameterAttrsL
-> MLuaTerm IdentL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall h (f :: Fragment) (a :: * -> *) j.
(PositionalParameter :<: f) =>
Cxt h f a ParameterAttrsL
-> Cxt h f a IdentL -> Cxt h f a FunctionParameterL
PositionalParameter' Cxt NoHole (Sum MLuaSig) (K ()) ParameterAttrsL
forall h (f :: Fragment) (a :: * -> *) j.
(EmptyParameterAttrs :<: f) =>
Cxt h f 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 (Cxt NoHole (Sum LuaSig) (K ())) FunNameL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunName (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunName LuaTerm NameL
n1 LuaTerm [NameL]
n2s Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
n3opt)) =
    case Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
n3opt of
      Just' LuaTerm NameL
n3 -> ([MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall l.
Typeable l =>
[Cxt NoHole (Sum MLuaSig) (K ()) l]
-> Cxt NoHole (Sum MLuaSig) (K ()) [l]
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)
      Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
Nothing' -> ([MLuaTerm IdentL] -> MLuaTerm [IdentL]
forall l.
Typeable l =>
[Cxt NoHole (Sum MLuaSig) (K ()) l]
-> Cxt NoHole (Sum MLuaSig) (K ()) [l]
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. HasCallStack => [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. HasCallStack => [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 l.
Cxt NoHole (Sum LuaSig) (K ()) [l]
-> [Cxt NoHole (Sum LuaSig) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF LuaTerm [NameL]
n2s

instance Trans F.Stat where
  trans :: forall l. Stat (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans (F.Assign LuaTerm [VarL]
vs LuaTerm [ExpL]
es) = CxtS NoHole MLuaSig (K ()) LhsL
-> CxtS NoHole MLuaSig (K ()) AssignOpL
-> CxtS NoHole MLuaSig (K ()) RhsL
-> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (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 :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a [VarL] -> CxtS h MLuaSig a LhsL
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]
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm [VarL]
vs) CxtS NoHole MLuaSig (K ()) AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpEquals :<: f) =>
Cxt h f a AssignOpL
AssignOpEquals' (CxtS NoHole MLuaSig (K ()) [ExpL]
-> CxtS NoHole MLuaSig (K ()) RhsL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a [ExpL] -> CxtS h MLuaSig a RhsL
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]
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm [ExpL]
es)
  trans (F.LocalAssign LuaTerm [NameL]
vs Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
init) = CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL
-> CxtS NoHole MLuaSig (K ()) l
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a SingleLocalVarDeclL -> CxtS h MLuaSig a l
injF (CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL
 -> CxtS NoHole MLuaSig (K ()) l)
-> CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL
-> CxtS NoHole MLuaSig (K ()) l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MLuaSig) (K ()) LocalVarDeclAttrsL
-> Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL
-> Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
-> CxtS NoHole MLuaSig (K ()) SingleLocalVarDeclL
forall h (f :: Fragment) (a :: * -> *) j.
(SingleLocalVarDecl :<: f) =>
Cxt h f a LocalVarDeclAttrsL
-> Cxt h f a VarDeclBinderL
-> Cxt h f a OptLocalVarInitL
-> Cxt h f a SingleLocalVarDeclL
SingleLocalVarDecl' Cxt NoHole (Sum MLuaSig) (K ()) LocalVarDeclAttrsL
forall h (f :: Fragment) (a :: * -> *) j.
(EmptyLocalVarDeclAttrs :<: f) =>
Cxt h f a LocalVarDeclAttrsL
EmptyLocalVarDeclAttrs' (MLuaTerm [IdentL] -> Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a [IdentL] -> CxtS h MLuaSig a VarDeclBinderL
injF (MLuaTerm [IdentL]
 -> Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL)
-> MLuaTerm [IdentL]
-> Cxt NoHole (Sum 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) Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
tInit
    where
      tInit :: Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
tInit = case Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
init of
        Just' LuaTerm [ExpL]
x  -> Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
-> Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
forall h (f :: Fragment) (a :: * -> *) j.
(OptLocalVarInit :<: f) =>
Cxt h f a LocalVarInitL -> Cxt h f a OptLocalVarInitL
JustLocalVarInit' (Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
 -> Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL)
-> Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
-> Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) [ExpL]
-> Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a [ExpL] -> CxtS h MLuaSig a LocalVarInitL
injF (CxtS NoHole MLuaSig (K ()) [ExpL]
 -> Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL)
-> CxtS NoHole MLuaSig (K ()) [ExpL]
-> Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
forall a b. (a -> b) -> a -> b
$ LuaTerm [ExpL] -> CxtS NoHole MLuaSig (K ()) [ExpL]
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm [ExpL]
x
        Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
Nothing' -> Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
forall h (f :: Fragment) (a :: * -> *) j.
(OptLocalVarInit :<: f) =>
Cxt h f a OptLocalVarInitL
NoLocalVarInit'
  trans (F.FunAssign LuaTerm FunNameL
fn (LuaTerm FunBodyL
-> Maybe (FunBody (Cxt NoHole (Sum LuaSig) (K ())) FunBodyL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunBody (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunBody LuaTerm [NameL]
pars Bool
varArg LuaTerm BlockL
body))) = CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
-> MLuaTerm IdentL
-> MLuaTerm [FunctionParameterL]
-> CxtS NoHole MLuaSig (K ()) FunctionBodyL
-> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (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 :: [Fragment]) (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 :: [Fragment]) (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 :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a BlockL -> CxtS h MLuaSig a FunctionBodyL
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
      (MLuaTerm [IdentL]
fnDefObjNms, MLuaTerm IdentL
funNm, Bool
isMethod) = LuaTerm FunNameL -> (MLuaTerm [IdentL], MLuaTerm IdentL, Bool)
splitLuaFunName LuaTerm FunNameL
fn

      addReceiverParam :: MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
      addReceiverParam :: MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
addReceiverParam MLuaTerm [FunctionParameterL]
x = if Bool
isMethod then Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
-> MLuaTerm [FunctionParameterL] -> MLuaTerm [FunctionParameterL]
forall (f :: Fragment) 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 h (f :: Fragment) (a :: * -> *) j.
(SelfParameter :<: f) =>
Cxt h f a FunctionParameterL
SelfParameter' MLuaTerm [FunctionParameterL]
x else MLuaTerm [FunctionParameterL]
x

  trans (F.LocalFunAssign LuaTerm NameL
n (LuaTerm FunBodyL
-> Maybe (FunBody (Cxt NoHole (Sum LuaSig) (K ())) FunBodyL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunBody (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.FunBody LuaTerm [NameL]
pars Bool
varArg LuaTerm BlockL
body))) = CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
-> MLuaTerm IdentL
-> MLuaTerm [FunctionParameterL]
-> CxtS NoHole MLuaSig (K ()) FunctionBodyL
-> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (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 h (f :: Fragment) (a :: * -> *) j.
(EmptyFunctionDefAttrs :<: f) =>
Cxt h f 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 :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a BlockL -> CxtS h MLuaSig a FunctionBodyL
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 Stat (Cxt NoHole (Sum LuaSig) (K ())) l
x = Stat (Cxt NoHole (Sum LuaSig) (K ())) l
-> CxtS NoHole MLuaSig (K ()) l
forall (f :: Fragment) l.
(HFunctor f, f :-<: MLuaSig, f :-<: LuaSig) =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
transDefault Stat (Cxt NoHole (Sum LuaSig) (K ())) l
x


translateFunArg :: F.LuaTerm F.FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg :: LuaTerm FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg (LuaTerm FunArgL
-> Maybe (FunArg (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Args LuaTerm [ExpL]
args))   = Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> MLuaTerm FunctionArgumentsL
forall h (f :: Fragment) (a :: * -> *) j.
(FunctionArgumentList :<: f) =>
Cxt h f a [FunctionArgumentL] -> Cxt h f a FunctionArgumentsL
FunctionArgumentList' ((Cxt NoHole (Sum LuaSig) (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> LuaTerm [ExpL]
-> Cxt NoHole (Sum 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 (Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall h (f :: Fragment) (a :: * -> *) j.
(PositionalArgument :<: f) =>
Cxt h f a PositionalArgExpL -> Cxt h f a FunctionArgumentL
PositionalArgument' (Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> Cxt NoHole (Sum 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
-> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a PositionalArgExpL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) ExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate) LuaTerm [ExpL]
args)
translateFunArg (LuaTerm FunArgL
-> Maybe (FunArg (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.TableArg Cxt NoHole (Sum LuaSig) (K ()) TableL
t))  = CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL
forall h (fs :: [Fragment]) (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
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) TableL
t
translateFunArg (LuaTerm FunArgL
-> Maybe (FunArg (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.StringArg Text
s)) = String -> MLuaTerm FunctionArgumentsL
forall h (fs :: [Fragment]) (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 :: forall l. FunCall (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans (F.NormalFunCall  LuaTerm PrefixExpL
f LuaTerm FunArgL
arg) = CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
-> MLuaTerm FunctionArgumentsL
-> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (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 h (f :: Fragment) (a :: * -> *) j.
(EmptyFunctionCallAttrs :<: f) =>
Cxt h f a FunctionCallAttrsL
EmptyFunctionCallAttrs' (CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a PrefixExpL -> CxtS h MLuaSig a FunctionExpL
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
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm PrefixExpL
f) (LuaTerm FunArgL -> MLuaTerm FunctionArgumentsL
translateFunArg LuaTerm FunArgL
arg)
  trans (F.MethodCall LuaTerm PrefixExpL
rec LuaTerm NameL
f LuaTerm FunArgL
arg) = CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MLuaSig (K ()) FunctionExpL
-> MLuaTerm FunctionArgumentsL
-> CxtS NoHole MLuaSig (K ()) l
forall h (fs :: [Fragment]) (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 h (f :: Fragment) (a :: * -> *) j.
(EmptyFunctionCallAttrs :<: f) =>
Cxt h f a FunctionCallAttrsL
EmptyFunctionCallAttrs' (MLuaTerm IdentL -> CxtS NoHole MLuaSig (K ()) FunctionExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a IdentL -> CxtS h MLuaSig a FunctionExpL
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 (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Args LuaTerm [ExpL]
as)) -> Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> MLuaTerm FunctionArgumentsL
forall h (f :: Fragment) (a :: * -> *) j.
(FunctionArgumentList :<: f) =>
Cxt h f a [FunctionArgumentL] -> Cxt h f a FunctionArgumentsL
FunctionArgumentList' (Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
-> Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
forall (f :: Fragment) 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 ()) ReceiverL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall h (f :: Fragment) (a :: * -> *) j.
(ReceiverArg :<: f) =>
Cxt h f a ReceiverL -> Cxt h f a FunctionArgumentL
ReceiverArg' (Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MLuaSig (K ()) PrefixExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a PrefixExpL -> CxtS h MLuaSig a ReceiverL
injF (CxtS NoHole MLuaSig (K ()) PrefixExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL)
-> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
forall a b. (a -> b) -> a -> b
$ LuaTerm PrefixExpL -> CxtS NoHole MLuaSig (K ()) PrefixExpL
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm PrefixExpL
rec)
                                                                                      ((Cxt NoHole (Sum LuaSig) (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> LuaTerm [ExpL]
-> Cxt NoHole (Sum 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 (Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
forall h (f :: Fragment) (a :: * -> *) j.
(PositionalArgument :<: f) =>
Cxt h f a PositionalArgExpL -> Cxt h f a FunctionArgumentL
PositionalArgument' (Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> Cxt NoHole (Sum 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
-> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a PositionalArgExpL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL)
-> (Cxt NoHole (Sum LuaSig) (K ()) ExpL
    -> CxtS NoHole MLuaSig (K ()) ExpL)
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate) LuaTerm [ExpL]
as))
                      (LuaTerm FunArgL
-> Maybe (FunArg (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.TableArg  Cxt NoHole (Sum LuaSig) (K ()) TableL
t)) -> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> CxtS NoHole MLuaSig (K ()) TableL -> MLuaTerm FunctionArgumentsL
forall h (fs :: [Fragment]) (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
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm PrefixExpL
rec) (Cxt NoHole (Sum LuaSig) (K ()) TableL
-> CxtS NoHole MLuaSig (K ()) TableL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) TableL
t)
                      (LuaTerm FunArgL
-> Maybe (FunArg (Cxt NoHole (Sum LuaSig) (K ())) FunArgL)
NatM
  Maybe
  (Cxt NoHole (Sum LuaSig) (K ()))
  (FunArg (Cxt NoHole (Sum LuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.StringArg Text
s)) -> CxtS NoHole MLuaSig (K ()) PrefixExpL
-> String -> MLuaTerm FunctionArgumentsL
forall h (fs :: [Fragment]) (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
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm PrefixExpL
rec) (Text -> String
unpack Text
s)

instance Trans F.FunArg where
  trans :: forall l. FunArg (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans FunArg (Cxt NoHole (Sum LuaSig) (K ())) l
_ = String -> MLuaTerm l
forall a. HasCallStack => String -> a
error String
"Lua FunArg found not with FunCall"

transUnOp :: F.LuaTerm F.UnopL -> Maybe (MLuaTerm UnaryOpL)
transUnOp :: LuaTerm UnopL -> Maybe (MLuaTerm UnaryOpL)
transUnOp LuaTerm UnopL
F.Neg' = MLuaTerm UnaryOpL -> Maybe (MLuaTerm UnaryOpL)
forall a. a -> Maybe a
Just MLuaTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(UnaryMinusOp :<: f) =>
Cxt h f a UnaryOpL
UnaryMinus'
transUnOp LuaTerm UnopL
F.Not' = MLuaTerm UnaryOpL -> Maybe (MLuaTerm UnaryOpL)
forall a. a -> Maybe a
Just MLuaTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalNegationOp :<: f) =>
Cxt h f a UnaryOpL
Not'
transUnOp LuaTerm UnopL
F.Complement' = MLuaTerm UnaryOpL -> Maybe (MLuaTerm UnaryOpL)
forall a. a -> Maybe a
Just MLuaTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ComplementOp :<: f) =>
Cxt h f a UnaryOpL
Complement'
-- transUnOp F.Len' = _
transUnOp LuaTerm UnopL
_ = Maybe (MLuaTerm UnaryOpL)
forall a. Maybe a
Nothing

translateUnary
  :: F.LuaTerm F.UnopL
  -> F.LuaTerm F.ExpL
  -> MLuaTerm F.ExpL
translateUnary :: LuaTerm UnopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
translateUnary (LuaTerm UnopL -> Maybe (MLuaTerm UnaryOpL)
transUnOp -> Just MLuaTerm UnaryOpL
op) Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp = MLuaTerm UnaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Operator :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a UnaryOpL -> CxtS h fs a ExpressionL -> CxtS h fs a j
iUnary MLuaTerm UnaryOpL
op (CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpressionL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpressionL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp)
translateUnary LuaTerm UnopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp = CxtS NoHole MLuaSig (K ()) UnopL
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Exp :-<: fs, InjF fs ExpL j) =>
CxtS h fs a UnopL -> CxtS h fs a ExpL -> CxtS h fs a j
F.iUnop (CxtS NoHole MLuaSig (K ()) UnopL
-> CxtS NoHole MLuaSig (K ()) UnopL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a UnopL -> CxtS h MLuaSig a UnopL
injF (CxtS NoHole MLuaSig (K ()) UnopL
 -> CxtS NoHole MLuaSig (K ()) UnopL)
-> CxtS NoHole MLuaSig (K ()) UnopL
-> CxtS NoHole MLuaSig (K ()) UnopL
forall a b. (a -> b) -> a -> b
$ LuaTerm UnopL -> CxtS NoHole MLuaSig (K ()) UnopL
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm UnopL
op) (CxtS NoHole MLuaSig (K ()) ExpL -> CxtS NoHole MLuaSig (K ()) ExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp)

transBinOp :: F.LuaTerm F.BinopL -> Maybe (MLuaTerm BinaryOpL)
transBinOp :: LuaTerm BinopL -> Maybe (MLuaTerm BinaryOpL)
transBinOp LuaTerm BinopL
F.Add' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Add'
transBinOp LuaTerm BinopL
F.Sub' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Sub'
transBinOp LuaTerm BinopL
F.Mul' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Mul'
transBinOp LuaTerm BinopL
F.Div' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(DivOp :<: f) =>
Cxt h f a BinaryOpL
Div'
transBinOp LuaTerm BinopL
F.Mod' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ModOp :<: f) =>
Cxt h f a BinaryOpL
Mod'
transBinOp LuaTerm BinopL
F.And' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalBinOp :<: f) =>
Cxt h f a BinaryOpL
LogicAnd'
transBinOp LuaTerm BinopL
F.Or' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalBinOp :<: f) =>
Cxt h f a BinaryOpL
LogicOr'
transBinOp LuaTerm BinopL
F.ShiftL' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ShlOp :<: f) =>
Cxt h f a BinaryOpL
Shl'
transBinOp LuaTerm BinopL
F.ShiftR' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalShrOp :<: f) =>
Cxt h f a BinaryOpL
LogicShr'
transBinOp LuaTerm BinopL
F.BAnd' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitAnd'
transBinOp LuaTerm BinopL
F.BOr' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitOr'
transBinOp LuaTerm BinopL
F.BXor' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitXor'
transBinOp LuaTerm BinopL
F.LT' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Lt'
transBinOp LuaTerm BinopL
F.LTE' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Lte'
transBinOp LuaTerm BinopL
F.GT' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Gt'
transBinOp LuaTerm BinopL
F.GTE' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Gte'
transBinOp LuaTerm BinopL
F.EQ' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Eq'
transBinOp LuaTerm BinopL
F.NEQ' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Neq'
transBinOp LuaTerm BinopL
F.IDiv' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(IDivOp :<: f) =>
Cxt h f a BinaryOpL
IDiv'
transBinOp LuaTerm BinopL
F.Exp' = MLuaTerm BinaryOpL -> Maybe (MLuaTerm BinaryOpL)
forall a. a -> Maybe a
Just MLuaTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ExpOp :<: f) =>
Cxt h f a BinaryOpL
Pow'
-- transBinOp F.Concat' = _
transBinOp LuaTerm BinopL
_ = Maybe (MLuaTerm BinaryOpL)
forall a. Maybe a
Nothing

translateBinary
  :: F.LuaTerm F.BinopL
  -> F.LuaTerm F.ExpL
  -> F.LuaTerm F.ExpL
  -> MLuaTerm F.ExpL
translateBinary :: LuaTerm BinopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
translateBinary (LuaTerm BinopL -> Maybe (MLuaTerm BinaryOpL)
transBinOp -> Just MLuaTerm BinaryOpL
op) Cxt NoHole (Sum LuaSig) (K ()) ExpL
a Cxt NoHole (Sum LuaSig) (K ()) ExpL
b = MLuaTerm BinaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Operator :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a BinaryOpL
-> CxtS h fs a ExpressionL
-> CxtS h fs a ExpressionL
-> CxtS h fs a j
iBinary MLuaTerm BinaryOpL
op (CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpressionL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpressionL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
a) (CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpressionL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpressionL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
b)
translateBinary LuaTerm BinopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
a Cxt NoHole (Sum LuaSig) (K ()) ExpL
b = CxtS NoHole MLuaSig (K ()) BinopL
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Exp :-<: fs, InjF fs ExpL j) =>
CxtS h fs a BinopL
-> CxtS h fs a ExpL -> CxtS h fs a ExpL -> CxtS h fs a j
F.iBinop (CxtS NoHole MLuaSig (K ()) BinopL
-> CxtS NoHole MLuaSig (K ()) BinopL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a BinopL -> CxtS h MLuaSig a BinopL
injF (CxtS NoHole MLuaSig (K ()) BinopL
 -> CxtS NoHole MLuaSig (K ()) BinopL)
-> CxtS NoHole MLuaSig (K ()) BinopL
-> CxtS NoHole MLuaSig (K ()) BinopL
forall a b. (a -> b) -> a -> b
$ LuaTerm BinopL -> CxtS NoHole MLuaSig (K ()) BinopL
forall l. LuaTerm l -> MLuaTerm l
translate LuaTerm BinopL
op) (CxtS NoHole MLuaSig (K ()) ExpL -> CxtS NoHole MLuaSig (K ()) ExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
a) (CxtS NoHole MLuaSig (K ()) ExpL -> CxtS NoHole MLuaSig (K ()) ExpL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h MLuaSig a ExpL -> CxtS h MLuaSig a ExpL
injF (CxtS NoHole MLuaSig (K ()) ExpL
 -> CxtS NoHole MLuaSig (K ()) ExpL)
-> CxtS NoHole MLuaSig (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
forall l. LuaTerm l -> MLuaTerm l
translate Cxt NoHole (Sum LuaSig) (K ()) ExpL
b)

instance Trans F.Exp where
  trans :: F.Exp F.LuaTerm l -> MLuaTerm l
  trans :: forall l. Exp (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
trans (F.Unop LuaTerm UnopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp) = LuaTerm UnopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
translateUnary LuaTerm UnopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
exp
  trans (F.Binop LuaTerm BinopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
a Cxt NoHole (Sum LuaSig) (K ()) ExpL
b) = LuaTerm BinopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> CxtS NoHole MLuaSig (K ()) ExpL
translateBinary LuaTerm BinopL
op Cxt NoHole (Sum LuaSig) (K ()) ExpL
a Cxt NoHole (Sum LuaSig) (K ()) ExpL
b
  trans Exp (Cxt NoHole (Sum LuaSig) (K ())) l
exp = Exp (Cxt NoHole (Sum LuaSig) (K ())) l
-> Cxt NoHole (Sum MLuaSig) (K ()) l
forall (f :: Fragment) l.
(HFunctor f, f :-<: MLuaSig, f :-<: LuaSig) =>
f (Cxt NoHole (Sum LuaSig) (K ())) l -> MLuaTerm l
transDefault Exp (Cxt NoHole (Sum LuaSig) (K ())) l
exp
  -- there is something called PEFunCall here, probably should translate it as well?
  -- trans (F.PrefixExp exp) = _

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

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

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

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

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

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

instance {-# OVERLAPPING #-} Untrans AssignIsStat where
  untrans :: forall l.
AssignIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (AssignIsStat (Assign' CxtS NoHole MLuaSig (K ()) LhsL
l CxtS NoHole MLuaSig (K ()) AssignOpL
_ CxtS NoHole MLuaSig (K ()) RhsL
r)) = LuaTerm [VarL] -> LuaTerm [ExpL] -> CxtS NoHole LuaSig (K ()) l
forall h (fs :: [Fragment]) (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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
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 :: [Fragment]) 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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
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 :: [Fragment]) 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 :: forall l.
SingleLocalVarDeclIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
untrans (SingleLocalVarDeclIsStat (SingleLocalVarDecl' Cxt NoHole (Sum MLuaSig) (K ()) LocalVarDeclAttrsL
_ Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL
b Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
init)) = LuaTerm [NameL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
-> CxtS NoHole LuaSig (K ()) l
forall h (fs :: [Fragment]) (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
$ Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL -> MLuaTerm [IdentL]
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MLuaSig) (K ()) VarDeclBinderL
b) Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
linit
    where
      linit :: Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
linit = case Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
init of
        Cxt NoHole (Sum MLuaSig) (K ()) OptLocalVarInitL
NoLocalVarInit'     -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall (f :: Fragment) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing'
        JustLocalVarInit' Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
x -> LuaTerm [ExpL] -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
forall (f :: Fragment) 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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate (CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL])
-> CxtS NoHole MLuaSig (K ()) [ExpL] -> LuaTerm [ExpL]
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
-> CxtS NoHole MLuaSig (K ()) [ExpL]
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MLuaSig) (K ()) LocalVarInitL
x

untransBlock :: MLuaTerm BlockL -> F.LuaTerm F.BlockL
untransBlock :: MLuaTerm BlockL -> LuaTerm BlockL
untransBlock (Block' Cxt NoHole (Sum MLuaSig) (K ()) [BlockItemL]
n Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL
e) = Cxt NoHole (Sum LuaSig) (K ()) [StatL]
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL]) -> LuaTerm BlockL
forall h (fs :: [Fragment]) (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)
-> Cxt NoHole (Sum 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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
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 :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF) Cxt NoHole (Sum MLuaSig) (K ()) [BlockItemL]
n) (CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
-> Cxt NoHole (Sum LuaSig) (K ()) (Maybe [ExpL])
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
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
$ Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL
-> CxtS NoHole MLuaSig (K ()) (Maybe [ExpL])
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MLuaSig) (K ()) BlockEndL
e)

instance {-# OVERLAPPING #-} Untrans BlockIsBlock where
  untrans :: forall l.
BlockIsBlock (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (BlockIsBlock 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 :: forall l.
FunctionCallIsFunCall (Cxt NoHole (Sum MLuaSig) (K ())) l
-> LuaTerm l
untrans (FunctionCallIsFunCall (FunctionCall' CxtS NoHole MLuaSig (K ()) FunctionCallAttrsL
EmptyFunctionCallAttrs' CxtS NoHole MLuaSig (K ()) FunctionExpL
f MLuaTerm FunctionArgumentsL
args)) =
      case Maybe (LuaTerm PrefixExpL)
receiver of
        Maybe (LuaTerm PrefixExpL)
Nothing -> LuaTerm PrefixExpL -> LuaTerm FunArgL -> LuaTerm l
forall h (fs :: [Fragment]) (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 (CxtS NoHole MLuaSig (K ()) FunctionExpL -> LuaTerm PrefixExpL
getFunPE CxtS NoHole MLuaSig (K ()) FunctionExpL
f) LuaTerm FunArgL
fa
        Just LuaTerm PrefixExpL
r  -> LuaTerm PrefixExpL -> LuaTerm NameL -> LuaTerm FunArgL -> LuaTerm l
forall h (fs :: [Fragment]) (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
      getFunPE :: MLuaTerm FunctionExpL -> F.LuaTerm F.PrefixExpL
      getFunPE :: CxtS NoHole MLuaSig (K ()) FunctionExpL -> LuaTerm PrefixExpL
getFunPE (CxtS NoHole MLuaSig (K ()) FunctionExpL
-> Maybe
     (PrefixExpIsFunctionExp
        (Cxt NoHole (Sum MLuaSig) (K ())) FunctionExpL)
NatM
  Maybe
  (Cxt NoHole (Sum MLuaSig) (K ()))
  (PrefixExpIsFunctionExp (Cxt NoHole (Sum MLuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (PrefixExpIsFunctionExp CxtS NoHole MLuaSig (K ()) PrefixExpL
x)) = CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
x
      getFunPE (CxtS NoHole MLuaSig (K ()) FunctionExpL
-> Maybe
     (FunctionIdent (Cxt NoHole (Sum MLuaSig) (K ())) FunctionExpL)
NatM
  Maybe
  (Cxt NoHole (Sum MLuaSig) (K ()))
  (FunctionIdent (Cxt NoHole (Sum MLuaSig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (FunctionIdent MLuaTerm IdentL
n))          = CxtS NoHole LuaSig (K ()) VarL -> LuaTerm PrefixExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(PrefixExp :-<: fs, InjF fs PrefixExpL j) =>
CxtS h fs a VarL -> CxtS h fs a j
F.iPEVar (CxtS NoHole LuaSig (K ()) VarL -> LuaTerm PrefixExpL)
-> CxtS NoHole LuaSig (K ()) VarL -> LuaTerm PrefixExpL
forall a b. (a -> b) -> a -> b
$ LuaTerm NameL -> CxtS NoHole LuaSig (K ()) VarL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Var :-<: fs, InjF fs VarL j) =>
CxtS h fs a NameL -> CxtS h fs a j
F.iVarName (LuaTerm NameL -> CxtS NoHole LuaSig (K ()) VarL)
-> LuaTerm NameL -> CxtS NoHole LuaSig (K ()) VarL
forall a b. (a -> b) -> a -> b
$ LuaTerm NameL -> LuaTerm NameL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
forall h (a :: * -> *).
CxtS h LuaSig a NameL -> CxtS h LuaSig a NameL
injF (LuaTerm NameL -> LuaTerm NameL) -> LuaTerm NameL -> LuaTerm NameL
forall a b. (a -> b) -> a -> b
$ MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
n

      funNm :: Maybe (F.LuaTerm F.NameL)
      funNm :: Maybe (LuaTerm NameL)
funNm = case CxtS NoHole MLuaSig (K ()) FunctionExpL
f of
              FunctionIdent' MLuaTerm IdentL
i -> LuaTerm NameL -> Maybe (LuaTerm NameL)
forall a. a -> Maybe a
Just (MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
i)
              CxtS NoHole MLuaSig (K ()) FunctionExpL
_                -> 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' Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
r) Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
_) -> (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL)
-> Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
-> Maybe (LuaTerm PrefixExpL)
forall a b. (a -> b) -> Maybe a -> Maybe b
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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
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
$ Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
-> Maybe (CxtS NoHole MLuaSig (K ()) PrefixExpL)
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> Maybe (CxtS h fs a l)
forall h (a :: * -> *).
CxtS h MLuaSig a ReceiverL -> Maybe (CxtS h MLuaSig a PrefixExpL)
projF Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
r
                   MLuaTerm FunctionArgumentsL
_     -> case MLuaTerm FunctionArgumentsL
args of
                                LuaReceiverAndTableArg'  CxtS NoHole MLuaSig (K ()) PrefixExpL
rec CxtS NoHole MLuaSig (K ()) TableL
_ -> LuaTerm PrefixExpL -> Maybe (LuaTerm PrefixExpL)
forall a. a -> Maybe a
Just (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
rec)
                                LuaReceiverAndStringArg' CxtS NoHole MLuaSig (K ()) PrefixExpL
rec String
_ -> LuaTerm PrefixExpL -> Maybe (LuaTerm PrefixExpL)
forall a. a -> Maybe a
Just (CxtS NoHole MLuaSig (K ()) PrefixExpL -> LuaTerm PrefixExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) PrefixExpL
rec)
                                MLuaTerm FunctionArgumentsL
_                              -> Maybe (LuaTerm PrefixExpL)
forall a. Maybe a
Nothing

      untransArgs :: MLuaTerm [FunctionArgumentL] -> F.LuaTerm [F.ExpL]
      untransArgs :: Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> LuaTerm [ExpL]
untransArgs = (Cxt NoHole (Sum MLuaSig) (K ()) FunctionArgumentL
 -> Cxt NoHole (Sum LuaSig) (K ()) ExpL)
-> Cxt NoHole (Sum 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' Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
p) = MLuaTerm l -> LuaTerm l
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate (MLuaTerm l -> LuaTerm l) -> MLuaTerm l -> LuaTerm l
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL -> MLuaTerm l
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF Cxt NoHole (Sum MLuaSig) (K ()) PositionalArgExpL
p

      fa :: F.LuaTerm F.FunArgL
      fa :: LuaTerm FunArgL
fa = case MLuaTerm FunctionArgumentsL
args of
             FunctionArgumentList' (ConsF' (ReceiverArg' Cxt NoHole (Sum MLuaSig) (K ()) ReceiverL
_) Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
as) -> LuaTerm [ExpL] -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a [ExpL] -> CxtS h fs a j
F.iArgs (Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> LuaTerm [ExpL]
untransArgs Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
as)
             FunctionArgumentList' Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
as                           -> LuaTerm [ExpL] -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
CxtS h fs a [ExpL] -> CxtS h fs a j
F.iArgs (Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
-> LuaTerm [ExpL]
untransArgs Cxt NoHole (Sum MLuaSig) (K ()) [FunctionArgumentL]
as)
             MLuaTerm FunctionArgumentsL
_      -> case MLuaTerm FunctionArgumentsL
args of
                          LuaTableArg'               CxtS NoHole MLuaSig (K ()) TableL
x -> Cxt NoHole (Sum LuaSig) (K ()) TableL -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) TableL
x)
                          LuaStringArg'              String
s -> Text -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(FunArg :-<: fs, InjF fs FunArgL j) =>
Text -> CxtS h fs a j
F.iStringArg (String -> Text
pack String
s)
                          LuaReceiverAndTableArg'  CxtS NoHole MLuaSig (K ()) PrefixExpL
_ CxtS NoHole MLuaSig (K ()) TableL
x -> Cxt NoHole (Sum LuaSig) (K ()) TableL -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (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 ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) TableL
x)
                          LuaReceiverAndStringArg' CxtS NoHole MLuaSig (K ()) PrefixExpL
_ String
s -> Text -> LuaTerm FunArgL
forall h (fs :: [Fragment]) (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 :: forall l.
FunctionDefIsStat (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (FunctionDefIsStat (FunctionDef' CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
attrs MLuaTerm IdentL
n MLuaTerm [FunctionParameterL]
params CxtS NoHole MLuaSig (K ()) FunctionBodyL
body)) =
      case CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
attrs of
        CxtS NoHole MLuaSig (K ()) FunctionDefAttrsL
EmptyFunctionDefAttrs'-> LuaTerm NameL -> LuaTerm FunBodyL -> LuaTerm l
forall h (fs :: [Fragment]) (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 :: [Fragment]) (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 :: [Fragment]) 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' MLuaTerm [IdentL]
nms)) -> LuaTerm FunNameL -> LuaTerm FunBodyL -> LuaTerm l
forall h (fs :: [Fragment]) (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 l.
Cxt NoHole (Sum MLuaSig) (K ()) [l]
-> [Cxt NoHole (Sum MLuaSig) (K ()) l]
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 :: [Fragment]) (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 :: [Fragment]) 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 l.
Cxt NoHole (Sum MLuaSig) (K ()) [l]
-> [Cxt NoHole (Sum MLuaSig) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF MLuaTerm [FunctionParameterL]
params
      ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
params', Bool
isVarargs) = if [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL] -> Int
forall a. [a] -> 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
> Int
0 then
                               case [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
forall a. HasCallStack => [a] -> a
last [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList of
                                 Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
LuaVarArgsParam' -> ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
-> [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
forall a. HasCallStack => [a] -> [a]
init [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList, Bool
True)
                                 Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL
_                -> ([Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
paramsList,      Bool
False)
                             else
                               ([], Bool
False)

      params'' :: LuaTerm [NameL]
params'' = [LuaTerm NameL] -> LuaTerm [NameL]
forall l.
Typeable l =>
[Cxt NoHole (Sum LuaSig) (K ()) l]
-> Cxt NoHole (Sum LuaSig) (K ()) [l]
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' Cxt NoHole (Sum MLuaSig) (K ()) ParameterAttrsL
EmptyParameterAttrs' MLuaTerm IdentL
n) = MLuaTerm IdentL -> LuaTerm NameL
untransIdent MLuaTerm IdentL
n

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

      congealFunName :: [MLuaTerm IdentL] -> F.LuaTerm F.FunNameL
      congealFunName :: [MLuaTerm IdentL] -> LuaTerm FunNameL
congealFunName [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 :: [Fragment]) (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. HasCallStack => [a] -> a
head [LuaTerm NameL]
nms') ([LuaTerm NameL] -> LuaTerm [NameL]
forall l.
Typeable l =>
[Cxt NoHole (Sum LuaSig) (K ()) l]
-> Cxt NoHole (Sum LuaSig) (K ()) [l]
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. HasCallStack => [a] -> [a]
tail [LuaTerm NameL]
nms') (LuaTerm NameL -> Cxt NoHole (Sum LuaSig) (K ()) (Maybe NameL)
forall (f :: Fragment) 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 :: [Fragment]) (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. HasCallStack => [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 l.
Typeable l =>
[Cxt NoHole (Sum LuaSig) (K ()) l]
-> Cxt NoHole (Sum LuaSig) (K ()) [l]
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 Int
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 :: Fragment) 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 [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. HasCallStack => [a] -> [a]
tail  [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l
                   | Bool
otherwise = [Cxt NoHole (Sum MLuaSig) (K ()) FunctionParameterL]
l

untransUnaryOp :: MLuaTerm UnaryOpL -> F.LuaTerm F.UnopL
untransUnaryOp :: MLuaTerm UnaryOpL -> LuaTerm UnopL
untransUnaryOp MLuaTerm UnaryOpL
UnaryMinus' = LuaTerm UnopL
forall h (f :: Fragment) (a :: * -> *) j.
(Unop :<: f) =>
Cxt h f a UnopL
F.Neg'
untransUnaryOp MLuaTerm UnaryOpL
Not' = LuaTerm UnopL
forall h (f :: Fragment) (a :: * -> *) j.
(Unop :<: f) =>
Cxt h f a UnopL
F.Not'
untransUnaryOp MLuaTerm UnaryOpL
Complement' = LuaTerm UnopL
forall h (f :: Fragment) (a :: * -> *) j.
(Unop :<: f) =>
Cxt h f a UnopL
F.Complement'

untransUnary
  :: MLuaTerm UnaryOpL
  -> MLuaTerm ExpressionL
  -> F.LuaTerm F.ExpL
untransUnary :: MLuaTerm UnaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransUnary MLuaTerm UnaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
e = LuaTerm UnopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Exp :-<: fs, InjF fs ExpL j) =>
CxtS h fs a UnopL -> CxtS h fs a ExpL -> CxtS h fs a j
F.iUnop (MLuaTerm UnaryOpL -> LuaTerm UnopL
untransUnaryOp MLuaTerm UnaryOpL
op) (CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransExpression CxtS NoHole MLuaSig (K ()) ExpressionL
e)

untransBinOp :: MLuaTerm BinaryOpL -> F.LuaTerm F.BinopL
untransBinOp :: MLuaTerm BinaryOpL -> LuaTerm BinopL
untransBinOp MLuaTerm BinaryOpL
Add' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Add'
untransBinOp MLuaTerm BinaryOpL
Sub' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Sub'
untransBinOp MLuaTerm BinaryOpL
Mul' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Mul'
untransBinOp MLuaTerm BinaryOpL
Div' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Div'
untransBinOp MLuaTerm BinaryOpL
Mod' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Mod'
untransBinOp MLuaTerm BinaryOpL
LogicAnd' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.And'
untransBinOp MLuaTerm BinaryOpL
LogicOr' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Or'
untransBinOp MLuaTerm BinaryOpL
Shl' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.ShiftL'
untransBinOp MLuaTerm BinaryOpL
LogicShr' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.ShiftR'
untransBinOp MLuaTerm BinaryOpL
BitAnd' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.BAnd'
untransBinOp MLuaTerm BinaryOpL
BitOr' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.BOr'
untransBinOp MLuaTerm BinaryOpL
BitXor' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.BXor'
untransBinOp MLuaTerm BinaryOpL
Lt' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.LT'
untransBinOp MLuaTerm BinaryOpL
Lte' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.LTE'
untransBinOp MLuaTerm BinaryOpL
Gt'  = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.GT'
untransBinOp MLuaTerm BinaryOpL
Gte' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.GTE'
untransBinOp MLuaTerm BinaryOpL
Eq' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.EQ'
untransBinOp MLuaTerm BinaryOpL
Neq' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.NEQ'
untransBinOp MLuaTerm BinaryOpL
IDiv' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.IDiv'
untransBinOp MLuaTerm BinaryOpL
Pow' = LuaTerm BinopL
forall h (f :: Fragment) (a :: * -> *) j.
(Binop :<: f) =>
Cxt h f a BinopL
F.Exp'

untransBinary
  :: MLuaTerm BinaryOpL
  -> MLuaTerm ExpressionL -> MLuaTerm ExpressionL
  -> F.LuaTerm F.ExpL
untransBinary :: MLuaTerm BinaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransBinary MLuaTerm BinaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
a CxtS NoHole MLuaSig (K ()) ExpressionL
b = LuaTerm BinopL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Exp :-<: fs, InjF fs ExpL j) =>
CxtS h fs a BinopL
-> CxtS h fs a ExpL -> CxtS h fs a ExpL -> CxtS h fs a j
F.iBinop (MLuaTerm BinaryOpL -> LuaTerm BinopL
untransBinOp MLuaTerm BinaryOpL
op) (CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransExpression CxtS NoHole MLuaSig (K ()) ExpressionL
a) (CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransExpression CxtS NoHole MLuaSig (K ()) ExpressionL
b)

untransExpression :: MLuaTerm ExpressionL -> F.LuaTerm F.ExpL
untransExpression :: CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransExpression (Unary' MLuaTerm UnaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
e) = MLuaTerm UnaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransUnary MLuaTerm UnaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
e
untransExpression (Binary' MLuaTerm BinaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
a CxtS NoHole MLuaSig (K ()) ExpressionL
b) = MLuaTerm BinaryOpL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransBinary MLuaTerm BinaryOpL
op CxtS NoHole MLuaSig (K ()) ExpressionL
a CxtS NoHole MLuaSig (K ()) ExpressionL
b
untransExpression (ExpIsExpression' CxtS NoHole MLuaSig (K ()) ExpL
e) = CxtS NoHole MLuaSig (K ()) ExpL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) ExpL
e

instance {-# OVERLAPPING #-} Untrans ExpressionIsExp where
  untrans :: forall l.
ExpressionIsExp (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (ExpressionIsExp CxtS NoHole MLuaSig (K ()) ExpressionL
e) = CxtS NoHole MLuaSig (K ()) ExpressionL
-> Cxt NoHole (Sum LuaSig) (K ()) ExpL
untransExpression CxtS NoHole MLuaSig (K ()) ExpressionL
e

untransExp :: MLuaTerm F.ExpL -> F.LuaTerm ExpressionL
untransExp :: CxtS NoHole MLuaSig (K ()) ExpL -> LuaTerm ExpressionL
untransExp (ExpressionIsExp' CxtS NoHole MLuaSig (K ()) ExpressionL
e) = CxtS NoHole MLuaSig (K ()) ExpressionL -> LuaTerm ExpressionL
Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate CxtS NoHole MLuaSig (K ()) ExpressionL
e

instance {-# OVERLAPPING #-} Untrans ExpIsExpression where
  untrans :: forall l.
ExpIsExpression (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
untrans (ExpIsExpression CxtS NoHole MLuaSig (K ()) ExpL
e) = CxtS NoHole MLuaSig (K ()) ExpL -> LuaTerm ExpressionL
untransExp CxtS NoHole MLuaSig (K ()) ExpL
e

untranslate :: MLuaTerm l -> F.LuaTerm l
untranslate :: Cxt NoHole (Sum MLuaSig) (K ()) :-> Cxt NoHole (Sum LuaSig) (K ())
untranslate = Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
forall l.
Sum MLuaSig (Cxt NoHole (Sum MLuaSig) (K ())) l -> LuaTerm l
forall (f :: Fragment) 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 :: Fragment) t. HFix f t -> f (HFix f) t
unTerm