{-# OPTIONS_HADDOCK hide #-}
{-# LANGUAGE CPP                     #-}
{-# 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    #-}

#ifdef ONLY_ONE_LANGUAGE
module Cubix.Language.JavaScript.Parametric.Common.Trans () where
#else
module Cubix.Language.JavaScript.Parametric.Common.Trans
  (
    translate
  , untranslate
  ) where

import Data.List ( (\\) )
import Data.Proxy
import Language.Haskell.TH.Syntax ( Type(ConT), Exp(VarE) )

import Control.Lens ( (&), (%~), _1 )

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

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

-------------------------------------------------------------------------------

noAnn :: (F.JSAnnot :-<: fs, All HFunctor fs) => Term fs F.JSAnnotL
noAnn :: Term fs JSAnnotL
noAnn = Term fs JSAnnotL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAnnot :-<: fs, InjF fs JSAnnotL j) =>
CxtS h fs a j
F.iJSNoAnnot

semi :: (F.JSSemi :-<: fs, F.JSAnnot :-<: fs, All HFunctor fs) => Term fs F.JSSemiL
semi :: Term fs JSSemiL
semi = CxtS NoHole fs (K ()) JSAnnotL -> Term fs JSSemiL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSSemi :-<: fs, InjF fs JSSemiL j) =>
CxtS h fs a JSAnnotL -> CxtS h fs a j
F.iJSSemi CxtS NoHole fs (K ()) JSAnnotL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAnnot :-<: fs, InjF fs JSAnnotL j) =>
CxtS h fs a j
F.iJSNoAnnot

jsCommaListToList :: F.JSTerm (F.JSCommaList l) -> [F.JSTerm l]
jsCommaListToList :: JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList (JSTerm (JSCommaList l)
-> Maybe
     (JSCommaListF (Cxt NoHole (Sum JSSig) (K ())) (JSCommaList l))
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.JSLCons xs :: Cxt NoHole (Sum JSSig) (K ()) (JSCommaList l)
xs _ x :: Cxt NoHole (Sum JSSig) (K ()) l
x)) = Cxt NoHole (Sum JSSig) (K ()) (JSCommaList l)
-> [Cxt NoHole (Sum JSSig) (K ()) l]
forall l. JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList Cxt NoHole (Sum JSSig) (K ()) (JSCommaList l)
xs [Cxt NoHole (Sum JSSig) (K ()) l]
-> [Cxt NoHole (Sum JSSig) (K ()) l]
-> [Cxt NoHole (Sum JSSig) (K ()) l]
forall a. [a] -> [a] -> [a]
++ [Cxt NoHole (Sum JSSig) (K ()) l
x]
jsCommaListToList (JSTerm (JSCommaList l)
-> Maybe
     (JSCommaListF (Cxt NoHole (Sum JSSig) (K ())) (JSCommaList l))
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.JSLOne x :: Cxt NoHole (Sum JSSig) (K ()) l
x))       = [JSTerm l
Cxt NoHole (Sum JSSig) (K ()) l
x]
jsCommaListToList (JSTerm (JSCommaList l)
-> Maybe
     (JSCommaListF (Cxt NoHole (Sum JSSig) (K ())) (JSCommaList l))
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just F.JSLNil)           = []


listToCommaList :: [F.JSTerm l] -> F.JSTerm (F.JSCommaList l)
listToCommaList :: [JSTerm l] -> JSTerm (JSCommaList l)
listToCommaList x :: [JSTerm l]
x = [JSTerm l] -> JSTerm (JSCommaList l)
forall (fs :: [(* -> *) -> * -> *]) l.
(KnownNat (Position JSCommaListF fs),
 KnownNat (Position JSAnnot fs), All HFunctor fs) =>
[Cxt NoHole (Sum fs) (K ()) l]
-> Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
listToCommaList' ([JSTerm l] -> JSTerm (JSCommaList l))
-> [JSTerm l] -> JSTerm (JSCommaList l)
forall a b. (a -> b) -> a -> b
$ [JSTerm l] -> [JSTerm l]
forall a. [a] -> [a]
reverse [JSTerm l]
x -- They have left-associative lists
  where
    listToCommaList' :: [Cxt NoHole (Sum fs) (K ()) l]
-> Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
listToCommaList' []     = Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
forall (f :: (* -> *) -> * -> *) h (a :: * -> *) l.
(JSCommaListF :<: f) =>
Cxt h f a (JSCommaList l)
F.riJSLNil
    listToCommaList' [x :: Cxt NoHole (Sum fs) (K ()) l
x]    = Cxt NoHole (Sum fs) (K ()) l
-> Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
forall (f :: (* -> *) -> * -> *) h (a :: * -> *) l.
(JSCommaListF :<: f) =>
Cxt h f a l -> Cxt h f a (JSCommaList l)
F.riJSLOne Cxt NoHole (Sum fs) (K ()) l
x
    listToCommaList' (x :: Cxt NoHole (Sum fs) (K ()) l
x:xs :: [Cxt NoHole (Sum fs) (K ()) l]
xs) = Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
-> Cxt NoHole (Sum fs) (K ()) JSAnnotL
-> Cxt NoHole (Sum fs) (K ()) l
-> Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
forall (f :: (* -> *) -> * -> *) h (a :: * -> *) l.
(JSCommaListF :<: f) =>
Cxt h f a (JSCommaList l)
-> Cxt h f a JSAnnotL -> Cxt h f a l -> Cxt h f a (JSCommaList l)
F.riJSLCons ([Cxt NoHole (Sum fs) (K ()) l]
-> Cxt NoHole (Sum fs) (K ()) (JSCommaList l)
listToCommaList' [Cxt NoHole (Sum fs) (K ()) l]
xs) Cxt NoHole (Sum fs) (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn Cxt NoHole (Sum fs) (K ()) l
x

-------------------------------------------------------------------------------

translate :: F.JSTerm l -> MJSTerm l
translate :: JSTerm l -> MJSTerm l
translate = Sum JSSig (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans (Sum JSSig (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l)
-> (JSTerm l -> Sum JSSig (Cxt NoHole (Sum JSSig) (K ())) l)
-> JSTerm l
-> MJSTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm l -> Sum JSSig (Cxt NoHole (Sum JSSig) (K ())) l
forall (f :: (* -> *) -> * -> *) t. HFix f t -> f (HFix f) t
unTerm

translate' :: (InjF MJSSig l l') => F.JSTerm l -> MJSTerm l'
translate' :: JSTerm l -> MJSTerm l'
translate' = CxtS NoHole MJSSig (K ()) l -> MJSTerm l'
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MJSSig (K ()) l -> MJSTerm l')
-> (JSTerm l -> CxtS NoHole MJSSig (K ()) l)
-> JSTerm l
-> MJSTerm l'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm l -> CxtS NoHole MJSSig (K ()) l
forall l. JSTerm l -> MJSTerm l
translate

class Trans f where
  trans :: f F.JSTerm l -> MJSTerm l

instance {-# OVERLAPPING #-} (All Trans fs) => Trans (Sum fs) where
  trans :: Sum fs (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans = Proxy Trans
-> (forall (f :: (* -> *) -> * -> *).
    Trans f =>
    f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l)
-> Sum fs (Cxt NoHole (Sum JSSig) (K ())) l
-> MJSTerm 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 (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
Trans f =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans

transDefault :: (HFunctor f, f :-<: MJSSig, f :-<: F.JSSig) => f F.JSTerm l -> MJSTerm l
transDefault :: f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
transDefault = f (Cxt NoHole (Sum MJSSig) (K ())) l -> MJSTerm l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum MJSSig) (K ())) l -> MJSTerm l)
-> (f (Cxt NoHole (Sum JSSig) (K ())) l
    -> f (Cxt NoHole (Sum MJSSig) (K ())) l)
-> f (Cxt NoHole (Sum JSSig) (K ())) l
-> MJSTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall l. JSTerm l -> MJSTerm l)
-> f (Cxt NoHole (Sum JSSig) (K ()))
   :-> f (Cxt NoHole (Sum MJSSig) (K ()))
forall (h :: (* -> *) -> * -> *) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap forall l. JSTerm l -> MJSTerm l
translate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: MJSSig, f :-<: F.JSSig) => Trans f where
  trans :: f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans = f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MJSSig, f :-<: JSSig) =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
transDefault


instance {-# OVERLAPPABLE #-} Trans F.JSVarInitializer where
  trans :: JSVarInitializer (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans = [Char]
-> JSVarInitializer (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall a. HasCallStack => [Char] -> a
error "JSVarInitializer found not within variable declaration"

translateAssign :: F.JSTerm F.JSExpressionL -> F.JSTerm F.JSAssignOpL -> F.JSTerm F.JSExpressionL -> MJSTerm F.JSExpressionL
translateAssign :: JSTerm JSExpressionL
-> JSTerm JSAssignOpL
-> JSTerm JSExpressionL
-> MJSTerm JSExpressionL
translateAssign lhs :: JSTerm JSExpressionL
lhs op :: JSTerm JSAssignOpL
op rhs :: JSTerm JSExpressionL
rhs = CxtS NoHole MJSSig (K ()) LhsL
-> CxtS NoHole MJSSig (K ()) AssignOpL
-> CxtS NoHole MJSSig (K ()) RhsL
-> MJSTerm JSExpressionL
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 (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LhsL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LhsL)
-> MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LhsL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
lhs) CxtS NoHole MJSSig (K ()) AssignOpL
op' (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) RhsL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) RhsL)
-> MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) RhsL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
rhs)
  where
    op' :: CxtS NoHole MJSSig (K ()) AssignOpL
op' = case JSTerm JSAssignOpL
-> Maybe (JSAssignOp (Cxt NoHole (Sum JSSig) (K ())) JSAssignOpL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project JSTerm JSAssignOpL
op of
      Just (F.JSAssign _) -> CxtS NoHole MJSSig (K ()) AssignOpL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(AssignOpEquals :-<: fs, All HFunctor fs) =>
CxtS h fs a AssignOpL
AssignOpEquals'
      _                   -> CxtS NoHole MJSSig (K ()) JSAssignOpL
-> CxtS NoHole MJSSig (K ()) AssignOpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MJSSig (K ()) JSAssignOpL
 -> CxtS NoHole MJSSig (K ()) AssignOpL)
-> CxtS NoHole MJSSig (K ()) JSAssignOpL
-> CxtS NoHole MJSSig (K ()) AssignOpL
forall a b. (a -> b) -> a -> b
$ JSTerm JSAssignOpL -> CxtS NoHole MJSSig (K ()) JSAssignOpL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSAssignOpL
op

-- This takes out things like "use strict";, which aren't really part of the computation,
-- and have to be at the front
splitDirectivePrelude :: [F.JSTerm F.JSStatementL] -> ([String], [F.JSTerm F.JSStatementL])
splitDirectivePrelude :: [JSTerm JSStatementL] -> ([[Char]], [JSTerm JSStatementL])
splitDirectivePrelude []     = ([], [])
splitDirectivePrelude (s :: JSTerm JSStatementL
s:ss :: [JSTerm JSStatementL]
ss) = case JSTerm JSStatementL -> Maybe [Char]
toDirective JSTerm JSStatementL
s of
                                 Nothing  -> ([], JSTerm JSStatementL
sJSTerm JSStatementL
-> [JSTerm JSStatementL] -> [JSTerm JSStatementL]
forall a. a -> [a] -> [a]
:[JSTerm JSStatementL]
ss)
                                 Just dir :: [Char]
dir -> ([JSTerm JSStatementL] -> ([[Char]], [JSTerm JSStatementL])
splitDirectivePrelude [JSTerm JSStatementL]
ss) ([[Char]], [JSTerm JSStatementL])
-> (([[Char]], [JSTerm JSStatementL])
    -> ([[Char]], [JSTerm JSStatementL]))
-> ([[Char]], [JSTerm JSStatementL])
forall a b. a -> (a -> b) -> b
& ([[Char]] -> Identity [[Char]])
-> ([[Char]], [JSTerm JSStatementL])
-> Identity ([[Char]], [JSTerm JSStatementL])
forall s t a b. Field1 s t a b => Lens s t a b
_1 (([[Char]] -> Identity [[Char]])
 -> ([[Char]], [JSTerm JSStatementL])
 -> Identity ([[Char]], [JSTerm JSStatementL]))
-> ([[Char]] -> [[Char]])
-> ([[Char]], [JSTerm JSStatementL])
-> ([[Char]], [JSTerm JSStatementL])
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ ([Char]
dir[Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
:)
  where
    toDirective :: F.JSTerm F.JSStatementL -> Maybe String
    toDirective :: JSTerm JSStatementL -> Maybe [Char]
toDirective (JSTerm JSStatementL
-> Maybe (JSStatement (Cxt NoHole (Sum JSSig) (K ())) JSStatementL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.JSExpressionStatement (JSTerm JSExpressionL
-> Maybe
     (JSExpression (Cxt NoHole (Sum JSSig) (K ())) JSExpressionL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.JSStringLiteral _ str :: [Char]
str)) _)) = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
str
    toDirective _ = Maybe [Char]
forall a. Maybe a
Nothing

translateBlock :: F.JSTerm F.JSBlockL -> MJSTerm F.JSBlockL
translateBlock :: JSTerm JSBlockL -> MJSTerm JSBlockL
translateBlock (JSTerm JSBlockL
-> Maybe (JSBlock (Cxt NoHole (Sum JSSig) (K ())) JSBlockL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.JSBlock _ ss :: Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
ss _)) = [[Char]] -> CxtS NoHole MJSSig (K ()) BlockL -> MJSTerm JSBlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(BlockWithPrelude :-<: fs, InjF fs JSBlockL j) =>
[[Char]] -> CxtS h fs a BlockL -> CxtS h fs a j
iBlockWithPrelude [[Char]]
dirPrelude CxtS NoHole MJSSig (K ()) BlockL
block
  where
    (dirPrelude :: [[Char]]
dirPrelude, blockStmts :: [JSTerm JSStatementL]
blockStmts) = [JSTerm JSStatementL] -> ([[Char]], [JSTerm JSStatementL])
splitDirectivePrelude ([JSTerm JSStatementL] -> ([[Char]], [JSTerm JSStatementL]))
-> [JSTerm JSStatementL] -> ([[Char]], [JSTerm JSStatementL])
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
-> [JSTerm JSStatementL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
ss

    block :: CxtS NoHole MJSSig (K ()) BlockL
block = CxtS NoHole MJSSig (K ()) [BlockItemL]
-> CxtS NoHole MJSSig (K ()) BlockEndL
-> CxtS NoHole MJSSig (K ()) BlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Block :-<: fs, InjF fs BlockL j) =>
CxtS h fs a [BlockItemL] -> CxtS h fs a BlockEndL -> CxtS h fs a j
iBlock ([Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> CxtS NoHole MJSSig (K ()) [BlockItemL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
 -> CxtS NoHole MJSSig (K ()) [BlockItemL])
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> CxtS NoHole MJSSig (K ()) [BlockItemL]
forall a b. (a -> b) -> a -> b
$ (JSTerm JSStatementL -> Cxt NoHole (Sum MJSSig) (K ()) BlockItemL)
-> [JSTerm JSStatementL]
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
forall a b. (a -> b) -> [a] -> [b]
map (CxtS NoHole MJSSig (K ()) JSStatementL
-> Cxt NoHole (Sum MJSSig) (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 MJSSig (K ()) JSStatementL
 -> Cxt NoHole (Sum MJSSig) (K ()) BlockItemL)
-> (JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> JSTerm JSStatementL
-> Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL
forall l. JSTerm l -> MJSTerm l
translate) [JSTerm JSStatementL]
blockStmts) CxtS NoHole MJSSig (K ()) BlockEndL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyBlockEnd :-<: fs, All HFunctor fs) =>
CxtS h fs a BlockEndL
EmptyBlockEnd'

translateFunCall :: F.JSTerm F.JSExpressionL -> F.JSTerm (F.JSCommaList F.JSExpressionL) -> MJSTerm FunctionCallL
translateFunCall :: JSTerm JSExpressionL
-> JSTerm (JSCommaList JSExpressionL) -> MJSTerm FunctionCallL
translateFunCall e :: JSTerm JSExpressionL
e args :: JSTerm (JSCommaList JSExpressionL)
args = CxtS NoHole MJSSig (K ()) FunctionCallAttrsL
-> CxtS NoHole MJSSig (K ()) FunctionExpL
-> CxtS NoHole MJSSig (K ()) FunctionArgumentsL
-> MJSTerm FunctionCallL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(FunctionCall :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionCallAttrsL
-> CxtS h fs a FunctionExpL
-> CxtS h fs a FunctionArgumentsL
-> CxtS h fs a FunctionCallL
FunctionCall' CxtS NoHole MJSSig (K ()) FunctionCallAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionCallAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionCallAttrsL
EmptyFunctionCallAttrs'
                                        (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) FunctionExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) FunctionExpL)
-> MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) FunctionExpL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
e)
                                        (CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> CxtS NoHole MJSSig (K ()) FunctionArgumentsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(FunctionArgumentList :-<: fs, All HFunctor fs) =>
CxtS h fs a [FunctionArgumentL] -> CxtS h fs a FunctionArgumentsL
FunctionArgumentList' (CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
 -> CxtS NoHole MJSSig (K ()) FunctionArgumentsL)
-> CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> CxtS NoHole MJSSig (K ()) FunctionArgumentsL
forall a b. (a -> b) -> a -> b
$ [Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL]
-> CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL]
 -> CxtS NoHole MJSSig (K ()) [FunctionArgumentL])
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL]
-> CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
forall a b. (a -> b) -> a -> b
$ (JSTerm JSExpressionL
 -> Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL)
-> [JSTerm JSExpressionL]
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL]
forall a b. (a -> b) -> [a] -> [b]
map (CxtS NoHole MJSSig (K ()) PositionalArgExpL
-> Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(PositionalArgument :-<: fs, All HFunctor fs) =>
CxtS h fs a PositionalArgExpL -> CxtS h fs a FunctionArgumentL
PositionalArgument' (CxtS NoHole MJSSig (K ()) PositionalArgExpL
 -> Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL)
-> (JSTerm JSExpressionL
    -> CxtS NoHole MJSSig (K ()) PositionalArgExpL)
-> JSTerm JSExpressionL
-> Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) PositionalArgExpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL
 -> CxtS NoHole MJSSig (K ()) PositionalArgExpL)
-> (JSTerm JSExpressionL -> MJSTerm JSExpressionL)
-> JSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) PositionalArgExpL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate)
                                                                               (JSTerm (JSCommaList JSExpressionL) -> [JSTerm JSExpressionL]
forall l. JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList JSTerm (JSCommaList JSExpressionL)
args))

instance Trans F.JSExpression where
  trans :: JSExpression (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans (F.JSIdentifier _ n :: [Char]
n)                     = [Char] -> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
[Char] -> CxtS h fs a j
iIdent [Char]
n
  trans (F.JSAssignExpression lhs :: JSTerm JSExpressionL
lhs op :: JSTerm JSAssignOpL
op rhs :: JSTerm JSExpressionL
rhs)        = JSTerm JSExpressionL
-> JSTerm JSAssignOpL
-> JSTerm JSExpressionL
-> MJSTerm JSExpressionL
translateAssign JSTerm JSExpressionL
lhs JSTerm JSAssignOpL
op JSTerm JSExpressionL
rhs
  trans (F.JSFunctionExpression _ a :: JSTerm JSIdentL
a _ b :: JSTerm (JSCommaList JSIdentL)
b _ block :: JSTerm JSBlockL
block) = CxtS NoHole MJSSig (K ()) JSAnnotL
-> CxtS NoHole MJSSig (K ()) JSIdentL
-> CxtS NoHole MJSSig (K ()) JSAnnotL
-> CxtS NoHole MJSSig (K ()) (JSCommaList JSIdentL)
-> CxtS NoHole MJSSig (K ()) JSAnnotL
-> MJSTerm JSBlockL
-> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSIdentL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSIdentL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSBlockL
-> CxtS h fs a j
F.iJSFunctionExpression CxtS NoHole MJSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (JSTerm JSIdentL -> CxtS NoHole MJSSig (K ()) JSIdentL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSIdentL
a) CxtS NoHole MJSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (JSTerm (JSCommaList JSIdentL)
-> CxtS NoHole MJSSig (K ()) (JSCommaList JSIdentL)
forall l. JSTerm l -> MJSTerm l
translate JSTerm (JSCommaList JSIdentL)
b) CxtS NoHole MJSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (JSTerm JSBlockL -> MJSTerm JSBlockL
translateBlock JSTerm JSBlockL
block)
  trans (F.JSMemberExpression f :: JSTerm JSExpressionL
f _ args :: JSTerm (JSCommaList JSExpressionL)
args _)        = MJSTerm FunctionCallL -> MJSTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm FunctionCallL -> MJSTerm l)
-> MJSTerm FunctionCallL -> MJSTerm l
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL
-> JSTerm (JSCommaList JSExpressionL) -> MJSTerm FunctionCallL
translateFunCall JSTerm JSExpressionL
f JSTerm (JSCommaList JSExpressionL)
args
  trans (F.JSCallExpression   f :: JSTerm JSExpressionL
f _ args :: JSTerm (JSCommaList JSExpressionL)
args _)        = MJSTerm FunctionCallL -> MJSTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm FunctionCallL -> MJSTerm l)
-> MJSTerm FunctionCallL -> MJSTerm l
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL
-> JSTerm (JSCommaList JSExpressionL) -> MJSTerm FunctionCallL
translateFunCall JSTerm JSExpressionL
f JSTerm (JSCommaList JSExpressionL)
args
  trans x :: JSExpression (Cxt NoHole (Sum JSSig) (K ())) l
x                                        = JSExpression (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MJSSig, f :-<: JSSig) =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
transDefault JSExpression (Cxt NoHole (Sum JSSig) (K ())) l
x

transIdent :: F.JSTerm F.JSIdentL -> MJSTerm IdentL
transIdent :: JSTerm JSIdentL -> MJSTerm IdentL
transIdent (JSTerm JSIdentL
-> Maybe (JSIdent (Cxt NoHole (Sum JSSig) (K ())) JSIdentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.JSIdentName _ n :: [Char]
n))) = [Char] -> MJSTerm IdentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Ident :-<: fs, All HFunctor fs) =>
[Char] -> CxtS h fs a IdentL
Ident' [Char]
n
transIdent (JSTerm JSIdentL
-> Maybe (JSIdent (Cxt NoHole (Sum JSSig) (K ())) JSIdentL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just F.JSIdentNone))       = [Char] -> MJSTerm IdentL
forall a. HasCallStack => [Char] -> a
error "JSIdentNone discovered where identifier was required"


instance Trans F.JSIdent where
  trans :: JSIdent (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans (F.JSIdentName _ n :: [Char]
n) = CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l)
-> CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l
forall a b. (a -> b) -> a -> b
$ MJSTerm IdentL -> CxtS NoHole MJSSig (K ()) (Maybe IdentL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a l -> Cxt h f a (Maybe l)
Just' (MJSTerm IdentL -> CxtS NoHole MJSSig (K ()) (Maybe IdentL))
-> MJSTerm IdentL -> CxtS NoHole MJSSig (K ()) (Maybe IdentL)
forall a b. (a -> b) -> a -> b
$ [Char] -> MJSTerm IdentL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(Ident :-<: fs, All HFunctor fs) =>
[Char] -> CxtS h fs a IdentL
Ident' [Char]
n
  trans F.JSIdentNone       = CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l)
-> CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> MJSTerm l
forall a b. (a -> b) -> a -> b
$ (CxtS NoHole MJSSig (K ()) (Maybe IdentL)
forall (f :: (* -> *) -> * -> *) l h (a :: * -> *).
(MaybeF :<: f, Typeable l, HFunctor f) =>
Cxt h f a (Maybe l)
Nothing' :: MJSTerm (Maybe IdentL))

varInitToDecl :: F.JSTerm F.JSExpressionL -> MJSTerm SingleLocalVarDeclL
varInitToDecl :: JSTerm JSExpressionL -> MJSTerm SingleLocalVarDeclL
varInitToDecl (JSTerm JSExpressionL
-> Maybe
     (JSExpression (Cxt NoHole (Sum JSSig) (K ())) JSExpressionL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (F.JSVarInitExpression lhs :: JSTerm JSExpressionL
lhs init :: Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
init))) =
          CxtS NoHole MJSSig (K ()) LocalVarDeclAttrsL
-> CxtS NoHole MJSSig (K ()) VarDeclBinderL
-> CxtS NoHole MJSSig (K ()) OptLocalVarInitL
-> MJSTerm 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 MJSSig (K ()) LocalVarDeclAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyLocalVarDeclAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a LocalVarDeclAttrsL
EmptyLocalVarDeclAttrs' (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) VarDeclBinderL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) VarDeclBinderL)
-> MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) VarDeclBinderL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
lhs) CxtS NoHole MJSSig (K ()) OptLocalVarInitL
rhs
  where
    rhs :: CxtS NoHole MJSSig (K ()) OptLocalVarInitL
rhs = case Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
-> Maybe
     (JSVarInitializer
        (Cxt NoHole (Sum JSSig) (K ())) JSVarInitializerL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
init of
      Just (F.JSVarInit _ e :: JSTerm JSExpressionL
e) -> CxtS NoHole MJSSig (K ()) LocalVarInitL
-> CxtS NoHole MJSSig (K ()) OptLocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(OptLocalVarInit :-<: fs, All HFunctor fs) =>
CxtS h fs a LocalVarInitL -> CxtS h fs a OptLocalVarInitL
JustLocalVarInit' (CxtS NoHole MJSSig (K ()) LocalVarInitL
 -> CxtS NoHole MJSSig (K ()) OptLocalVarInitL)
-> CxtS NoHole MJSSig (K ()) LocalVarInitL
-> CxtS NoHole MJSSig (K ()) OptLocalVarInitL
forall a b. (a -> b) -> a -> b
$ MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LocalVarInitL)
-> MJSTerm JSExpressionL -> CxtS NoHole MJSSig (K ()) LocalVarInitL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
e
      Just F.JSVarInitNone   -> CxtS NoHole MJSSig (K ()) OptLocalVarInitL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(OptLocalVarInit :-<: fs, All HFunctor fs) =>
CxtS h fs a OptLocalVarInitL
NoLocalVarInit'

extractVarDecls :: F.JSTerm (F.JSCommaList F.JSExpressionL) -> MJSTerm [SingleLocalVarDeclL]
extractVarDecls :: JSTerm (JSCommaList JSExpressionL) -> MJSTerm [SingleLocalVarDeclL]
extractVarDecls commaList :: JSTerm (JSCommaList JSExpressionL)
commaList = [MJSTerm SingleLocalVarDeclL] -> MJSTerm [SingleLocalVarDeclL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([MJSTerm SingleLocalVarDeclL] -> MJSTerm [SingleLocalVarDeclL])
-> [MJSTerm SingleLocalVarDeclL] -> MJSTerm [SingleLocalVarDeclL]
forall a b. (a -> b) -> a -> b
$ (JSTerm JSExpressionL -> MJSTerm SingleLocalVarDeclL)
-> [JSTerm JSExpressionL] -> [MJSTerm SingleLocalVarDeclL]
forall a b. (a -> b) -> [a] -> [b]
map JSTerm JSExpressionL -> MJSTerm SingleLocalVarDeclL
varInitToDecl [JSTerm JSExpressionL]
exps
  where
    exps :: [JSTerm JSExpressionL]
exps = JSTerm (JSCommaList JSExpressionL) -> [JSTerm JSExpressionL]
forall l. JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList JSTerm (JSCommaList JSExpressionL)
commaList

transCommaExpList :: F.JSTerm (F.JSCommaList F.JSExpressionL) -> MJSTerm [F.JSExpressionL]
transCommaExpList :: JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList = [MJSTerm JSExpressionL] -> MJSTerm [JSExpressionL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([MJSTerm JSExpressionL] -> MJSTerm [JSExpressionL])
-> (JSTerm (JSCommaList JSExpressionL) -> [MJSTerm JSExpressionL])
-> JSTerm (JSCommaList JSExpressionL)
-> MJSTerm [JSExpressionL]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (JSTerm JSExpressionL -> MJSTerm JSExpressionL)
-> [JSTerm JSExpressionL] -> [MJSTerm JSExpressionL]
forall a b. (a -> b) -> [a] -> [b]
map JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate ([JSTerm JSExpressionL] -> [MJSTerm JSExpressionL])
-> (JSTerm (JSCommaList JSExpressionL) -> [JSTerm JSExpressionL])
-> JSTerm (JSCommaList JSExpressionL)
-> [MJSTerm JSExpressionL]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm (JSCommaList JSExpressionL) -> [JSTerm JSExpressionL]
forall l. JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList

transParams :: F.JSTerm (F.JSCommaList F.JSIdentL) -> MJSTerm [FunctionParameterL]
transParams :: JSTerm (JSCommaList JSIdentL) -> MJSTerm [FunctionParameterL]
transParams args :: JSTerm (JSCommaList JSIdentL)
args = [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
-> MJSTerm [FunctionParameterL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
 -> MJSTerm [FunctionParameterL])
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
-> MJSTerm [FunctionParameterL]
forall a b. (a -> b) -> a -> b
$ (JSTerm JSIdentL
 -> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL)
-> [JSTerm JSIdentL]
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
forall a b. (a -> b) -> [a] -> [b]
map (MJSTerm IdentL -> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
makeParam(MJSTerm IdentL
 -> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL)
-> (JSTerm JSIdentL -> MJSTerm IdentL)
-> JSTerm JSIdentL
-> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.JSTerm JSIdentL -> MJSTerm IdentL
transIdent) (JSTerm (JSCommaList JSIdentL) -> [JSTerm JSIdentL]
forall l. JSTerm (JSCommaList l) -> [JSTerm l]
jsCommaListToList JSTerm (JSCommaList JSIdentL)
args)
  where
    makeParam :: MJSTerm IdentL -> MJSTerm FunctionParameterL
    makeParam :: MJSTerm IdentL -> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
makeParam n :: MJSTerm IdentL
n = CxtS NoHole MJSSig (K ()) ParameterAttrsL
-> MJSTerm IdentL
-> Cxt NoHole (Sum MJSSig) (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 MJSSig (K ()) ParameterAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyParameterAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a ParameterAttrsL
EmptyParameterAttrs' MJSTerm IdentL
n

instance Trans F.JSStatement where
  trans :: JSStatement (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans (F.JSVariable _ exprs :: JSTerm (JSCommaList JSExpressionL)
exprs _)      = CxtS NoHole MJSSig (K ()) MultiLocalVarDeclCommonAttrsL
-> MJSTerm [SingleLocalVarDeclL] -> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(MultiLocalVarDecl :-<: fs, InjF fs MultiLocalVarDeclL j) =>
CxtS h fs a MultiLocalVarDeclCommonAttrsL
-> CxtS h fs a [SingleLocalVarDeclL] -> CxtS h fs a j
iMultiLocalVarDecl CxtS NoHole MJSSig (K ()) MultiLocalVarDeclCommonAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyMultiLocalVarDeclCommonAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a MultiLocalVarDeclCommonAttrsL
EmptyMultiLocalVarDeclCommonAttrs'
                                                         (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [SingleLocalVarDeclL]
extractVarDecls JSTerm (JSCommaList JSExpressionL)
exprs)
  trans (F.JSFor _ _ init :: JSTerm (JSCommaList JSExpressionL)
init _ exp :: JSTerm (JSCommaList JSExpressionL)
exp _ upd :: JSTerm (JSCommaList JSExpressionL)
upd _ s :: JSTerm JSStatementL
s)      = MJSTerm [JSExpressionL]
-> MJSTerm [JSExpressionL]
-> MJSTerm [JSExpressionL]
-> CxtS NoHole MJSSig (K ()) JSStatementL
-> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSFor :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a [JSExpressionL]
-> CxtS h fs a [JSExpressionL]
-> CxtS h fs a [JSExpressionL]
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
iJSFor (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList JSTerm (JSCommaList JSExpressionL)
init) (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList JSTerm (JSCommaList JSExpressionL)
exp) (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList JSTerm (JSCommaList JSExpressionL)
upd) (JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSStatementL
s)
  trans (F.JSForIn _ _ v :: JSTerm JSExpressionL
v op :: JSTerm JSBinOpL
op exp :: JSTerm JSExpressionL
exp _ s :: JSTerm JSStatementL
s)            = MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSBinOpL
-> MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSStatementL
-> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSFor :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSExpressionL
-> CxtS h fs a JSBinOpL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
iJSForIn (JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
v) (JSTerm JSBinOpL -> CxtS NoHole MJSSig (K ()) JSBinOpL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSBinOpL
op) (JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
exp) (JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSStatementL
s)
  trans (F.JSForVar _ _ _ init :: JSTerm (JSCommaList JSExpressionL)
init _ exp :: JSTerm (JSCommaList JSExpressionL)
exp _ upd :: JSTerm (JSCommaList JSExpressionL)
upd _ s :: JSTerm JSStatementL
s) = MJSTerm [SingleLocalVarDeclL]
-> MJSTerm [JSExpressionL]
-> MJSTerm [JSExpressionL]
-> CxtS NoHole MJSSig (K ()) JSStatementL
-> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSFor :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a [SingleLocalVarDeclL]
-> CxtS h fs a [JSExpressionL]
-> CxtS h fs a [JSExpressionL]
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
iJSForVar (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [SingleLocalVarDeclL]
extractVarDecls JSTerm (JSCommaList JSExpressionL)
init) (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList JSTerm (JSCommaList JSExpressionL)
exp) (JSTerm (JSCommaList JSExpressionL) -> MJSTerm [JSExpressionL]
transCommaExpList JSTerm (JSCommaList JSExpressionL)
upd) (JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSStatementL
s)
  trans (F.JSForVarIn _ _ _ v :: JSTerm JSExpressionL
v op :: JSTerm JSBinOpL
op exp :: JSTerm JSExpressionL
exp _ s :: JSTerm JSStatementL
s)       = MJSTerm SingleLocalVarDeclL
-> CxtS NoHole MJSSig (K ()) JSBinOpL
-> MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSStatementL
-> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSFor :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a SingleLocalVarDeclL
-> CxtS h fs a JSBinOpL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
iJSForVarIn (JSTerm JSExpressionL -> MJSTerm SingleLocalVarDeclL
varInitToDecl JSTerm JSExpressionL
v) (JSTerm JSBinOpL -> CxtS NoHole MJSSig (K ()) JSBinOpL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSBinOpL
op) (JSTerm JSExpressionL -> MJSTerm JSExpressionL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSExpressionL
exp) (JSTerm JSStatementL -> CxtS NoHole MJSSig (K ()) JSStatementL
forall l. JSTerm l -> MJSTerm l
translate JSTerm JSStatementL
s)
  trans (F.JSConstant _ _ _)                    = [Char] -> MJSTerm l
forall a. HasCallStack => [Char] -> a
error "ES7 Const not supported"
  trans (F.JSAssignStatement lhs :: JSTerm JSExpressionL
lhs op :: JSTerm JSAssignOpL
op rhs :: JSTerm JSExpressionL
rhs s :: JSTerm JSSemiL
s)      = MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSSemiL -> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSExpressionL -> CxtS h fs a JSSemiL -> CxtS h fs a j
F.iJSExpressionStatement (JSTerm JSExpressionL
-> JSTerm JSAssignOpL
-> JSTerm JSExpressionL
-> MJSTerm JSExpressionL
translateAssign JSTerm JSExpressionL
lhs JSTerm JSAssignOpL
op JSTerm JSExpressionL
rhs) CxtS NoHole MJSSig (K ()) JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi
  trans (F.JSFunction _ n :: JSTerm JSIdentL
n _ args :: JSTerm (JSCommaList JSIdentL)
args _ block :: JSTerm JSBlockL
block _)     = CxtS NoHole MJSSig (K ()) FunctionDefAttrsL
-> MJSTerm IdentL
-> MJSTerm [FunctionParameterL]
-> CxtS NoHole MJSSig (K ()) FunctionBodyL
-> MJSTerm 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 MJSSig (K ()) FunctionDefAttrsL
forall (fs :: [(* -> *) -> * -> *]) h (a :: * -> *).
(EmptyFunctionDefAttrs :-<: fs, All HFunctor fs) =>
CxtS h fs a FunctionDefAttrsL
EmptyFunctionDefAttrs' (JSTerm JSIdentL -> MJSTerm IdentL
transIdent JSTerm JSIdentL
n) (JSTerm (JSCommaList JSIdentL) -> MJSTerm [FunctionParameterL]
transParams JSTerm (JSCommaList JSIdentL)
args) (MJSTerm JSBlockL -> CxtS NoHole MJSSig (K ()) FunctionBodyL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSBlockL -> CxtS NoHole MJSSig (K ()) FunctionBodyL)
-> MJSTerm JSBlockL -> CxtS NoHole MJSSig (K ()) FunctionBodyL
forall a b. (a -> b) -> a -> b
$ JSTerm JSBlockL -> MJSTerm JSBlockL
translateBlock JSTerm JSBlockL
block)
  trans (F.JSMethodCall f :: JSTerm JSExpressionL
f _ args :: JSTerm (JSCommaList JSExpressionL)
args _ _)           = MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSSemiL -> MJSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSExpressionL -> CxtS h fs a JSSemiL -> CxtS h fs a j
F.iJSExpressionStatement (MJSTerm FunctionCallL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm FunctionCallL -> MJSTerm JSExpressionL)
-> MJSTerm FunctionCallL -> MJSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ JSTerm JSExpressionL
-> JSTerm (JSCommaList JSExpressionL) -> MJSTerm FunctionCallL
translateFunCall JSTerm JSExpressionL
f JSTerm (JSCommaList JSExpressionL)
args) CxtS NoHole MJSSig (K ()) JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi
  trans x :: JSStatement (Cxt NoHole (Sum JSSig) (K ())) l
x                                       = JSStatement (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MJSSig, f :-<: JSSig) =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
transDefault JSStatement (Cxt NoHole (Sum JSSig) (K ())) l
x

instance Trans F.JSAST where
  trans :: JSAST (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
trans (F.JSAstProgram stmts :: Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
stmts _) = MJSTerm JSBlockL -> MJSTerm l
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l -> CxtS h fs a l'
injF (MJSTerm JSBlockL -> MJSTerm l) -> MJSTerm JSBlockL -> MJSTerm l
forall a b. (a -> b) -> a -> b
$ JSTerm JSBlockL -> MJSTerm JSBlockL
translateBlock (CxtS NoHole JSSig (K ()) JSAnnotL
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSBlockL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSBlock :-<: fs, InjF fs JSBlockL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a [JSStatementL]
-> CxtS h fs a JSAnnotL
-> CxtS h fs a j
F.iJSBlock CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
stmts CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn)
  trans x :: JSAST (Cxt NoHole (Sum JSSig) (K ())) l
x                        = JSAST (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
forall (f :: (* -> *) -> * -> *) l.
(HFunctor f, f :-<: MJSSig, f :-<: JSSig) =>
f (Cxt NoHole (Sum JSSig) (K ())) l -> MJSTerm l
transDefault JSAST (Cxt NoHole (Sum JSSig) (K ())) l
x

-------------------------------------------------------------------------------

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

class Untrans f where
  untrans :: f MJSTerm l -> F.JSTerm l

instance {-# OVERLAPPING #-} (All Untrans fs) => Untrans (Sum fs) where
  untrans :: Sum fs (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans = Proxy Untrans
-> (forall (f :: (* -> *) -> * -> *).
    Untrans f =>
    f (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l)
-> Sum fs (Cxt NoHole (Sum MJSSig) (K ())) l
-> JSTerm 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 MJSSig) (K ())) l -> JSTerm l
forall (f :: (* -> *) -> * -> *) l.
Untrans f =>
f (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans

untransDefault :: (HFunctor f, f :-<: F.JSSig) => f MJSTerm l -> F.JSTerm l
untransDefault :: f (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untransDefault = f (Cxt NoHole (Sum JSSig) (K ())) l -> JSTerm l
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum JSSig) (K ())) l -> JSTerm l)
-> (f (Cxt NoHole (Sum MJSSig) (K ())) l
    -> f (Cxt NoHole (Sum JSSig) (K ())) l)
-> f (Cxt NoHole (Sum MJSSig) (K ())) l
-> JSTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ()))
-> f (Cxt NoHole (Sum MJSSig) (K ()))
   :-> f (Cxt NoHole (Sum JSSig) (K ()))
forall (h :: (* -> *) -> * -> *) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate

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

instance {-# OVERLAPPING #-} Untrans IdentIsJSExpression where
  untrans :: IdentIsJSExpression (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (IdentIsJSExpression (Ident' n :: [Char]
n)) = CxtS NoHole JSSig (K ()) JSAnnotL -> [Char] -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSAnnotL -> [Char] -> CxtS h fs a j
F.iJSIdentifier CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn [Char]
n


untransDecl :: MJSTerm SingleLocalVarDeclL -> F.JSTerm F.JSExpressionL
untransDecl :: MJSTerm SingleLocalVarDeclL -> JSTerm JSExpressionL
untransDecl (SingleLocalVarDecl' _ lhs :: CxtS NoHole MJSSig (K ()) VarDeclBinderL
lhs init :: CxtS NoHole MJSSig (K ()) OptLocalVarInitL
init) =
       JSTerm JSExpressionL
-> Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
-> JSTerm JSExpressionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSExpressionL
-> CxtS h fs a JSVarInitializerL -> CxtS h fs a j
F.iJSVarInitExpression (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> MJSTerm JSExpressionL -> JSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) VarDeclBinderL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) VarDeclBinderL
lhs) Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
varInit
  where
    varInit :: Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
varInit = case CxtS NoHole MJSSig (K ()) OptLocalVarInitL
init of
      JustLocalVarInit' e :: CxtS NoHole MJSSig (K ()) LocalVarInitL
e -> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSExpressionL
-> Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSVarInitializer :-<: fs, InjF fs JSVarInitializerL j) =>
CxtS h fs a JSAnnotL -> CxtS h fs a JSExpressionL -> CxtS h fs a j
F.iJSVarInit CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> MJSTerm JSExpressionL -> JSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) LocalVarInitL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) LocalVarInitL
e)
      NoLocalVarInit'     -> Cxt NoHole (Sum JSSig) (K ()) JSVarInitializerL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSVarInitializer :-<: fs, InjF fs JSVarInitializerL j) =>
CxtS h fs a j
F.iJSVarInitNone

untransDecls :: MJSTerm [SingleLocalVarDeclL] -> F.JSTerm (F.JSCommaList F.JSExpressionL)
untransDecls :: MJSTerm [SingleLocalVarDeclL] -> JSTerm (JSCommaList JSExpressionL)
untransDecls x :: MJSTerm [SingleLocalVarDeclL]
x = [JSTerm JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
forall l. [JSTerm l] -> JSTerm (JSCommaList l)
listToCommaList ([JSTerm JSExpressionL] -> JSTerm (JSCommaList JSExpressionL))
-> [JSTerm JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
forall a b. (a -> b) -> a -> b
$ (MJSTerm SingleLocalVarDeclL -> JSTerm JSExpressionL)
-> [MJSTerm SingleLocalVarDeclL] -> [JSTerm JSExpressionL]
forall a b. (a -> b) -> [a] -> [b]
map MJSTerm SingleLocalVarDeclL -> JSTerm JSExpressionL
untransDecl ([MJSTerm SingleLocalVarDeclL] -> [JSTerm JSExpressionL])
-> [MJSTerm SingleLocalVarDeclL] -> [JSTerm JSExpressionL]
forall a b. (a -> b) -> a -> b
$ MJSTerm [SingleLocalVarDeclL] -> [MJSTerm SingleLocalVarDeclL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF MJSTerm [SingleLocalVarDeclL]
x


instance {-# OVERLAPPING #-} Untrans MultiLocalVarDeclIsJSStatement where
  untrans :: MultiLocalVarDeclIsJSStatement (Cxt NoHole (Sum MJSSig) (K ())) l
-> JSTerm l
untrans (MultiLocalVarDeclIsJSStatement (MultiLocalVarDecl' _ decs :: MJSTerm [SingleLocalVarDeclL]
decs)) = CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL) -> JSTerm JSSemiL -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSSemiL
-> CxtS h fs a j
F.iJSVariable CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [SingleLocalVarDeclL] -> JSTerm (JSCommaList JSExpressionL)
untransDecls MJSTerm [SingleLocalVarDeclL]
decs) JSTerm JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi

untransOp :: MJSTerm AssignOpL -> F.JSTerm F.JSAssignOpL
untransOp :: CxtS NoHole MJSSig (K ()) AssignOpL -> JSTerm JSAssignOpL
untransOp AssignOpEquals' = CxtS NoHole JSSig (K ()) JSAnnotL -> JSTerm JSAssignOpL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAssignOp :-<: fs, InjF fs JSAssignOpL j) =>
CxtS h fs a JSAnnotL -> CxtS h fs a j
F.iJSAssign CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn
untransOp x :: CxtS NoHole MJSSig (K ()) AssignOpL
x               = CxtS NoHole MJSSig (K ()) JSAssignOpL -> JSTerm JSAssignOpL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (CxtS NoHole MJSSig (K ()) JSAssignOpL -> JSTerm JSAssignOpL)
-> CxtS NoHole MJSSig (K ()) JSAssignOpL -> JSTerm JSAssignOpL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) AssignOpL
-> CxtS NoHole MJSSig (K ()) JSAssignOpL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) AssignOpL
x

instance {-# OVERLAPPING #-} Untrans AssignIsJSExpression where
  untrans :: AssignIsJSExpression (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (AssignIsJSExpression (Assign' lhs :: CxtS NoHole MJSSig (K ()) LhsL
lhs op :: CxtS NoHole MJSSig (K ()) AssignOpL
op rhs :: CxtS NoHole MJSSig (K ()) RhsL
rhs)) = JSTerm JSExpressionL
-> JSTerm JSAssignOpL -> JSTerm JSExpressionL -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSExpressionL
-> CxtS h fs a JSAssignOpL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a j
F.iJSAssignExpression (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> MJSTerm JSExpressionL -> JSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) LhsL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) LhsL
lhs) (CxtS NoHole MJSSig (K ()) AssignOpL -> JSTerm JSAssignOpL
untransOp CxtS NoHole MJSSig (K ()) AssignOpL
op) (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> MJSTerm JSExpressionL -> JSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) RhsL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) RhsL
rhs)


toJSString :: String -> MJSTerm F.JSStatementL
toJSString :: [Char] -> CxtS NoHole MJSSig (K ()) JSStatementL
toJSString s :: [Char]
s = MJSTerm JSExpressionL
-> CxtS NoHole MJSSig (K ()) JSSemiL
-> CxtS NoHole MJSSig (K ()) JSStatementL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSExpressionL -> CxtS h fs a JSSemiL -> CxtS h fs a j
F.iJSExpressionStatement (CxtS NoHole MJSSig (K ()) JSAnnotL
-> [Char] -> MJSTerm JSExpressionL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSAnnotL -> [Char] -> CxtS h fs a j
F.iJSStringLiteral CxtS NoHole MJSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn [Char]
s) CxtS NoHole MJSSig (K ()) JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi

instance {-# OVERLAPPING #-} Untrans BlockWithPrelude where
  untrans :: BlockWithPrelude (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (BlockWithPrelude dirPrelude :: [[Char]]
dirPrelude (Block' ss :: CxtS NoHole MJSSig (K ()) [BlockItemL]
ss _)) = CxtS NoHole JSSig (K ()) JSAnnotL
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSBlock :-<: fs, InjF fs JSBlockL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a [JSStatementL]
-> CxtS h fs a JSAnnotL
-> CxtS h fs a j
F.iJSBlock CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn ([JSTerm JSStatementL]
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([JSTerm JSStatementL]
 -> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL])
-> [JSTerm JSStatementL]
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
forall a b. (a -> b) -> a -> b
$ (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL)
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [JSTerm JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate [CxtS NoHole MJSSig (K ()) JSStatementL]
stmts) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn
    where
      stmts :: [CxtS NoHole MJSSig (K ()) JSStatementL]
stmts = (([Char] -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> [[Char]] -> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> CxtS NoHole MJSSig (K ()) JSStatementL
toJSString [[Char]]
dirPrelude) [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a. [a] -> [a] -> [a]
++ ((Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
 -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
-> CxtS NoHole MJSSig (K ()) JSStatementL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF ([Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
 -> [CxtS NoHole MJSSig (K ()) JSStatementL])
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) [BlockItemL]
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF CxtS NoHole MJSSig (K ()) [BlockItemL]
ss)


instance {-# OVERLAPPING #-} Untrans BlockIsJSStatement where
  untrans :: BlockIsJSStatement (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (BlockIsJSStatement (Block' ss :: CxtS NoHole MJSSig (K ()) [BlockItemL]
ss _)) = CxtS NoHole JSSig (K ()) JSAnnotL
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSSemiL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a [JSStatementL]
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSSemiL
-> CxtS h fs a j
F.iJSStatementBlock CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn ((Cxt NoHole (Sum MJSSig) (K ()) BlockItemL -> JSTerm JSStatementL)
-> CxtS NoHole MJSSig (K ()) [BlockItemL]
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
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 MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate(CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL)
-> (Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
    -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
-> JSTerm JSStatementL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
-> CxtS NoHole MJSSig (K ()) JSStatementL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF) CxtS NoHole MJSSig (K ()) [BlockItemL]
ss) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn JSTerm JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi


untransCommaListExp :: MJSTerm [F.JSExpressionL] -> F.JSTerm (F.JSCommaList F.JSExpressionL)
untransCommaListExp :: MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp = [JSTerm JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
forall l. [JSTerm l] -> JSTerm (JSCommaList l)
listToCommaList ([JSTerm JSExpressionL] -> JSTerm (JSCommaList JSExpressionL))
-> (MJSTerm [JSExpressionL] -> [JSTerm JSExpressionL])
-> MJSTerm [JSExpressionL]
-> JSTerm (JSCommaList JSExpressionL)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> [MJSTerm JSExpressionL] -> [JSTerm JSExpressionL]
forall a b. (a -> b) -> [a] -> [b]
map MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate ([MJSTerm JSExpressionL] -> [JSTerm JSExpressionL])
-> (MJSTerm [JSExpressionL] -> [MJSTerm JSExpressionL])
-> MJSTerm [JSExpressionL]
-> [JSTerm JSExpressionL]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MJSTerm [JSExpressionL] -> [MJSTerm JSExpressionL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF

instance {-# OVERLAPPING #-} Untrans JSFor where
  untrans :: JSFor (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (JSFor init :: MJSTerm [JSExpressionL]
init exp :: MJSTerm [JSExpressionL]
exp upd :: MJSTerm [JSExpressionL]
upd s :: CxtS NoHole MJSSig (K ()) JSStatementL
s)   = CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSStatementL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
F.iJSFor CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp MJSTerm [JSExpressionL]
init) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp MJSTerm [JSExpressionL]
exp) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp MJSTerm [JSExpressionL]
upd) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSStatementL
s)
  untrans (JSForIn lhs :: MJSTerm JSExpressionL
lhs b :: CxtS NoHole MJSSig (K ()) JSBinOpL
b e :: MJSTerm JSExpressionL
e s :: CxtS NoHole MJSSig (K ()) JSStatementL
s)      = CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSExpressionL
-> JSTerm JSBinOpL
-> JSTerm JSExpressionL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSStatementL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSBinOpL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
F.iJSForIn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate MJSTerm JSExpressionL
lhs) (CxtS NoHole MJSSig (K ()) JSBinOpL -> JSTerm JSBinOpL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSBinOpL
b) (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate MJSTerm JSExpressionL
e) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSStatementL
s)
  untrans (JSForVar dec :: MJSTerm [SingleLocalVarDeclL]
dec exp :: MJSTerm [JSExpressionL]
exp upd :: MJSTerm [JSExpressionL]
upd s :: CxtS NoHole MJSSig (K ()) JSStatementL
s) = CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSStatementL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
F.iJSForVar CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [SingleLocalVarDeclL] -> JSTerm (JSCommaList JSExpressionL)
untransDecls MJSTerm [SingleLocalVarDeclL]
dec) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp MJSTerm [JSExpressionL]
exp) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp MJSTerm [JSExpressionL]
upd) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSStatementL
s)
  untrans (JSForVarIn dec :: MJSTerm SingleLocalVarDeclL
dec b :: CxtS NoHole MJSSig (K ()) JSBinOpL
b e :: MJSTerm JSExpressionL
e s :: CxtS NoHole MJSSig (K ()) JSStatementL
s)   = CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSExpressionL
-> JSTerm JSBinOpL
-> JSTerm JSExpressionL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSStatementL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSBinOpL
-> CxtS h fs a JSExpressionL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSStatementL
-> CxtS h fs a j
F.iJSForVarIn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm SingleLocalVarDeclL -> JSTerm JSExpressionL
untransDecl MJSTerm SingleLocalVarDeclL
dec) (CxtS NoHole MJSSig (K ()) JSBinOpL -> JSTerm JSBinOpL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSBinOpL
b) (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate MJSTerm JSExpressionL
e) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate CxtS NoHole MJSSig (K ()) JSStatementL
s)

untransIdent :: MJSTerm IdentL -> F.JSTerm F.JSIdentL
untransIdent :: MJSTerm IdentL -> JSTerm JSIdentL
untransIdent (Ident' s :: [Char]
s) = CxtS NoHole JSSig (K ()) JSAnnotL -> [Char] -> JSTerm JSIdentL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSIdent :-<: fs, InjF fs JSIdentL j) =>
CxtS h fs a JSAnnotL -> [Char] -> CxtS h fs a j
F.iJSIdentName CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn [Char]
s

instance {-# OVERLAPPING #-} Untrans MaybeIdentIsJSIdent where
  untrans :: MaybeIdentIsJSIdent (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (MaybeIdentIsJSIdent x :: CxtS NoHole MJSSig (K ()) (Maybe IdentL)
x) = case CxtS NoHole MJSSig (K ()) (Maybe IdentL) -> Maybe (MJSTerm IdentL)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF CxtS NoHole MJSSig (K ()) (Maybe IdentL)
x of
    Just (Ident' s :: [Char]
s) -> CxtS NoHole JSSig (K ()) JSAnnotL -> [Char] -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSIdent :-<: fs, InjF fs JSIdentL j) =>
CxtS h fs a JSAnnotL -> [Char] -> CxtS h fs a j
F.iJSIdentName CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn [Char]
s
    Nothing         -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSIdent :-<: fs, InjF fs JSIdentL j) =>
CxtS h fs a j
F.iJSIdentNone

instance {-# OVERLAPPING #-} Untrans JSBlockIsJSAST where
  untrans :: JSBlockIsJSAST (Cxt NoHole (Sum MJSSig) (K ())) l -> JSTerm l
untrans (JSBlockIsJSAST (MJSTerm JSBlockL
-> Maybe
     (BlockWithPrelude (Cxt NoHole (Sum MJSSig) (K ())) JSBlockL)
forall (g :: (* -> *) -> * -> *) (f :: (* -> *) -> * -> *) h
       (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> (Just (BlockWithPrelude dirPrelude :: [[Char]]
dirPrelude (Block' ss :: CxtS NoHole MJSSig (K ()) [BlockItemL]
ss _))))) = Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
-> CxtS NoHole JSSig (K ()) JSAnnotL -> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAST :-<: fs, InjF fs JSASTL j) =>
CxtS h fs a [JSStatementL] -> CxtS h fs a JSAnnotL -> CxtS h fs a j
F.iJSAstProgram ([JSTerm JSStatementL]
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([JSTerm JSStatementL]
 -> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL])
-> [JSTerm JSStatementL]
-> Cxt NoHole (Sum JSSig) (K ()) [JSStatementL]
forall a b. (a -> b) -> a -> b
$ (CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL)
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [JSTerm JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map CxtS NoHole MJSSig (K ()) JSStatementL -> JSTerm JSStatementL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate [CxtS NoHole MJSSig (K ()) JSStatementL]
stmts) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn
    where
      stmts :: [MJSTerm F.JSStatementL]
      stmts :: [CxtS NoHole MJSSig (K ()) JSStatementL]
stmts = (([Char] -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> [[Char]] -> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> CxtS NoHole MJSSig (K ()) JSStatementL
toJSString [[Char]]
dirPrelude) [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a. [a] -> [a] -> [a]
++ ((Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
 -> CxtS NoHole MJSSig (K ()) JSStatementL)
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> [a] -> [b]
map Cxt NoHole (Sum MJSSig) (K ()) BlockItemL
-> CxtS NoHole MJSSig (K ()) JSStatementL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF ([Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
 -> [CxtS NoHole MJSSig (K ()) JSStatementL])
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
-> [CxtS NoHole MJSSig (K ()) JSStatementL]
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) [BlockItemL]
-> [Cxt NoHole (Sum MJSSig) (K ()) BlockItemL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF CxtS NoHole MJSSig (K ()) [BlockItemL]
ss)

untransArgs :: MJSTerm [FunctionArgumentL] -> F.JSTerm (F.JSCommaList F.JSExpressionL)
untransArgs :: CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> JSTerm (JSCommaList JSExpressionL)
untransArgs = MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL)
untransCommaListExp (MJSTerm [JSExpressionL] -> JSTerm (JSCommaList JSExpressionL))
-> (CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
    -> MJSTerm [JSExpressionL])
-> CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> JSTerm (JSCommaList JSExpressionL)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL
 -> MJSTerm JSExpressionL)
-> CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> MJSTerm [JSExpressionL]
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 MJSSig) (K ()) FunctionArgumentL
-> MJSTerm JSExpressionL
untransArg
  where
    untransArg :: MJSTerm FunctionArgumentL -> MJSTerm F.JSExpressionL
    untransArg :: Cxt NoHole (Sum MJSSig) (K ()) FunctionArgumentL
-> MJSTerm JSExpressionL
untransArg (PositionalArgument' x :: CxtS NoHole MJSSig (K ()) PositionalArgExpL
x) = CxtS NoHole MJSSig (K ()) PositionalArgExpL
-> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) PositionalArgExpL
x

instance {-# OVERLAPPING #-} Untrans FunctionCallIsJSExpression where
  untrans :: FunctionCallIsJSExpression (Cxt NoHole (Sum MJSSig) (K ())) l
-> JSTerm l
untrans (FunctionCallIsJSExpression (FunctionCall' EmptyFunctionCallAttrs' f :: CxtS NoHole MJSSig (K ()) FunctionExpL
f (FunctionArgumentList' args :: CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
args))) = JSTerm JSExpressionL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSExpressionL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSExpression :-<: fs, InjF fs JSExpressionL j) =>
CxtS h fs a JSExpressionL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSExpressionL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a j
F.iJSCallExpression (MJSTerm JSExpressionL -> JSTerm JSExpressionL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSExpressionL -> JSTerm JSExpressionL)
-> MJSTerm JSExpressionL -> JSTerm JSExpressionL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) FunctionExpL -> MJSTerm JSExpressionL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) FunctionExpL
f) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
-> JSTerm (JSCommaList JSExpressionL)
untransArgs CxtS NoHole MJSSig (K ()) [FunctionArgumentL]
args) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn

untransParams :: MJSTerm [FunctionParameterL] -> F.JSTerm (F.JSCommaList F.JSIdentL)
untransParams :: MJSTerm [FunctionParameterL] -> JSTerm (JSCommaList JSIdentL)
untransParams params :: MJSTerm [FunctionParameterL]
params = [JSTerm JSIdentL] -> JSTerm (JSCommaList JSIdentL)
forall l. [JSTerm l] -> JSTerm (JSCommaList l)
listToCommaList ([JSTerm JSIdentL] -> JSTerm (JSCommaList JSIdentL))
-> [JSTerm JSIdentL] -> JSTerm (JSCommaList JSIdentL)
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
 -> JSTerm JSIdentL)
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
-> [JSTerm JSIdentL]
forall a b. (a -> b) -> [a] -> [b]
map (MJSTerm IdentL -> JSTerm JSIdentL
untransIdent(MJSTerm IdentL -> JSTerm JSIdentL)
-> (Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
    -> MJSTerm IdentL)
-> Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL
-> JSTerm JSIdentL
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL -> MJSTerm IdentL
paramToIdent) ([Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
 -> [JSTerm JSIdentL])
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
-> [JSTerm JSIdentL]
forall a b. (a -> b) -> a -> b
$ MJSTerm [FunctionParameterL]
-> [Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF MJSTerm [FunctionParameterL]
params
  where
    paramToIdent :: MJSTerm FunctionParameterL -> MJSTerm IdentL
    paramToIdent :: Cxt NoHole (Sum MJSSig) (K ()) FunctionParameterL -> MJSTerm IdentL
paramToIdent (PositionalParameter' EmptyParameterAttrs' n :: MJSTerm IdentL
n) = MJSTerm IdentL
n

instance {-# OVERLAPPING #-} Untrans FunctionDefIsJSStatement where
  untrans :: FunctionDefIsJSStatement (Cxt NoHole (Sum MJSSig) (K ())) l
-> JSTerm l
untrans (FunctionDefIsJSStatement (FunctionDef' EmptyFunctionDefAttrs' n :: MJSTerm IdentL
n params :: MJSTerm [FunctionParameterL]
params block :: CxtS NoHole MJSSig (K ()) FunctionBodyL
block)) = CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSIdentL
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm (JSCommaList JSIdentL)
-> CxtS NoHole JSSig (K ()) JSAnnotL
-> JSTerm JSBlockL
-> JSTerm JSSemiL
-> JSTerm l
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSStatement :-<: fs, InjF fs JSStatementL j) =>
CxtS h fs a JSAnnotL
-> CxtS h fs a JSIdentL
-> CxtS h fs a JSAnnotL
-> CxtS h fs a (JSCommaList JSIdentL)
-> CxtS h fs a JSAnnotL
-> CxtS h fs a JSBlockL
-> CxtS h fs a JSSemiL
-> CxtS h fs a j
F.iJSFunction CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm IdentL -> JSTerm JSIdentL
untransIdent MJSTerm IdentL
n) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm [FunctionParameterL] -> JSTerm (JSCommaList JSIdentL)
untransParams MJSTerm [FunctionParameterL]
params) CxtS NoHole JSSig (K ()) JSAnnotL
forall (fs :: [(* -> *) -> * -> *]).
(JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSAnnotL
noAnn (MJSTerm JSBlockL -> JSTerm JSBlockL
Cxt NoHole (Sum MJSSig) (K ()) :-> Cxt NoHole (Sum JSSig) (K ())
untranslate (MJSTerm JSBlockL -> JSTerm JSBlockL)
-> MJSTerm JSBlockL -> JSTerm JSBlockL
forall a b. (a -> b) -> a -> b
$ CxtS NoHole MJSSig (K ()) FunctionBodyL -> MJSTerm JSBlockL
forall (fs :: [(* -> *) -> * -> *]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MJSSig (K ()) FunctionBodyL
block) JSTerm JSSemiL
forall (fs :: [(* -> *) -> * -> *]).
(JSSemi :-<: fs, JSAnnot :-<: fs, All HFunctor fs) =>
Term fs JSSemiL
semi

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

do ipsNames <- sumToNames ''MJSSig
   modNames <- sumToNames ''F.JSSig
   let targTs = map ConT $ (ipsNames \\ modNames)
                           \\ [ ''JSBlockIsJSAST, ''MaybeIdentIsJSIdent, ''JSFor, ''BlockIsJSStatement, ''BlockWithPrelude
                              , ''AssignIsJSExpression, ''MultiLocalVarDeclIsJSStatement, ''IdentIsJSExpression
                              , ''FunctionCallIsJSExpression, ''FunctionDefIsJSStatement]
   return $ makeDefaultInstances targTs ''Untrans 'untrans (VarE 'untransError)

#endif