{-# OPTIONS_HADDOCK hide #-}

{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE TemplateHaskell       #-}
{-# LANGUAGE UndecidableInstances  #-}

module Cubix.Language.Solidity.IPS.Trans (
    translate
  , untranslate
  ) where

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

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

import Cubix.Language.Solidity.IPS.Types
import Cubix.Language.Solidity.Modularized qualified as F
import Cubix.Language.Parametric.Derive
import Cubix.Language.Parametric.InjF
import Cubix.Language.Parametric.Syntax
import Data.Typeable (Typeable)

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


------------------------------------------------------------------------------------
---------------- Forward translation: Modularized syntax to IPS  -------------------
------------------------------------------------------------------------------------

--------------------------------
------------- Top-level translate
--------------------------------

------ Top-level definition

translate :: F.SolidityTerm l -> MSolidityTerm l
translate :: forall l. SolidityTerm l -> MSolidityTerm l
translate = Sum SoliditySig (Cxt NoHole (Sum SoliditySig) (K ())) l
-> MSolidityTerm l
forall l.
Sum SoliditySig (Cxt NoHole (Sum SoliditySig) (K ())) l
-> MSolidityTerm l
forall (f :: Fragment) l.
Trans f =>
f (Cxt NoHole (Sum SoliditySig) (K ())) l -> MSolidityTerm l
trans (Sum SoliditySig (Cxt NoHole (Sum SoliditySig) (K ())) l
 -> MSolidityTerm l)
-> (SolidityTerm l
    -> Sum SoliditySig (Cxt NoHole (Sum SoliditySig) (K ())) l)
-> SolidityTerm l
-> MSolidityTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: Fragment) t. HFix f t -> f (HFix f) t
unTerm @(Sum F.SoliditySig)

translate' :: (InjF MSoliditySig l l') => F.SolidityTerm l -> MSolidityTerm l'
translate' :: forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' = CxtS NoHole MSoliditySig (K ()) l
-> CxtS NoHole MSoliditySig (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 MSoliditySig a l -> CxtS h MSoliditySig a l'
injF (CxtS NoHole MSoliditySig (K ()) l
 -> CxtS NoHole MSoliditySig (K ()) l')
-> (SolidityTerm l -> CxtS NoHole MSoliditySig (K ()) l)
-> SolidityTerm l
-> CxtS NoHole MSoliditySig (K ()) l'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SolidityTerm l -> CxtS NoHole MSoliditySig (K ()) l
forall l. SolidityTerm l -> MSolidityTerm l
translate

------ Class

class Trans f where
  trans :: f F.SolidityTerm l -> MSolidityTerm l

------ Default and standard cases

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

transDefault :: (HFunctor f, f :-<: MSoliditySig, f :-<: F.SoliditySig) => f F.SolidityTerm l -> MSolidityTerm l
transDefault :: forall (f :: Fragment) l.
(HFunctor f, f :-<: MSoliditySig, f :-<: SoliditySig) =>
f (Cxt NoHole (Sum SoliditySig) (K ())) l -> MSolidityTerm l
transDefault = f (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> Cxt NoHole (Sum MSoliditySig) (K ()) l
f (Cxt NoHole (Sum MSoliditySig) (K ()))
:-> Cxt NoHole (Sum MSoliditySig) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum MSoliditySig) (K ())) l
 -> Cxt NoHole (Sum MSoliditySig) (K ()) l)
-> (f (Cxt NoHole (Sum SoliditySig) (K ())) l
    -> f (Cxt NoHole (Sum MSoliditySig) (K ())) l)
-> f (Cxt NoHole (Sum SoliditySig) (K ())) l
-> Cxt NoHole (Sum MSoliditySig) (K ()) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall l. SolidityTerm l -> MSolidityTerm l)
-> f (Cxt NoHole (Sum SoliditySig) (K ()))
   :-> f (Cxt NoHole (Sum MSoliditySig) (K ()))
forall (f :: * -> *) (g :: * -> *). (f :-> g) -> f f :-> f g
forall (h :: Fragment) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap SolidityTerm i -> MSolidityTerm i
forall l. SolidityTerm l -> MSolidityTerm l
translate

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

---------------------------------
-------------- Per-fragment Instances
---------------------------------

-------- Identifiers

transIdent :: F.SolidityTerm F.IdentifierL -> MSolidityTerm IdentL
transIdent :: SolidityTerm IdentifierL -> MSolidityTerm IdentL
transIdent (SolidityTerm IdentifierL
-> Maybe
     (Identifier (Cxt NoHole (Sum SoliditySig) (K ())) IdentifierL)
NatM
  Maybe
  (Cxt NoHole (Sum SoliditySig) (K ()))
  (Identifier (Cxt NoHole (Sum SoliditySig) (K ())))
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
NatM Maybe (Cxt h f a) (g (Cxt h f a))
project -> Just (F.Identifier Text
t)) = String -> MSolidityTerm IdentL
forall h (f :: Fragment) (a :: * -> *) j.
(Ident :<: f) =>
String -> Cxt h f a IdentL
Ident' (Text -> String
Text.unpack Text
t)

-- Clone of transIdent because type-safe pattern match
instance Trans F.Identifier where
  trans :: forall l.
Identifier (Cxt NoHole (Sum SoliditySig) (K ())) l
-> MSolidityTerm l
trans (F.Identifier Text
n) = String -> CxtS NoHole MSoliditySig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Ident :-<: fs, InjF fs IdentL j) =>
String -> CxtS h fs a j
iIdent (Text -> String
Text.unpack Text
n)

transUnop :: F.SolidityTerm F.UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
transUnop :: SolidityTerm UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
transUnop SolidityTerm UnaryOpL
F.UPreSub' = MSolidityTerm UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(UnaryMinusOp :<: f) =>
Cxt h f a UnaryOpL
UnaryMinus'
transUnop SolidityTerm UnaryOpL
F.UPreBitNot' = MSolidityTerm UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ComplementOp :<: f) =>
Cxt h f a UnaryOpL
Complement'
transUnop SolidityTerm UnaryOpL
F.UPreNot' = MSolidityTerm UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm UnaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalNegationOp :<: f) =>
Cxt h f a UnaryOpL
Not'
transUnop SolidityTerm UnaryOpL
_ = Maybe (MSolidityTerm UnaryOpL)
forall a. Maybe a
Nothing

translateUnary
  :: F.SolidityTerm F.UnaryOpL
  -> F.SolidityTerm F.ExpressionL
  -> MSolidityTerm ExpressionL
translateUnary :: SolidityTerm UnaryOpL
-> SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateUnary (SolidityTerm UnaryOpL -> Maybe (MSolidityTerm UnaryOpL)
transUnop -> Just MSolidityTerm UnaryOpL
op) SolidityTerm ExpressionL
exp = MSolidityTerm UnaryOpL
-> MSolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall h (f :: Fragment) (a :: * -> *) j.
(Operator :<: f) =>
Cxt h f a UnaryOpL
-> Cxt h f a ExpressionL -> Cxt h f a ExpressionL
Unary' MSolidityTerm UnaryOpL
op (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm ExpressionL
exp)
translateUnary SolidityTerm UnaryOpL
op SolidityTerm ExpressionL
exp = CxtS NoHole MSoliditySig (K ()) UnaryOpL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
-> MSolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a UnaryOpL -> CxtS h fs a ExpressionL -> CxtS h fs a j
F.iUnaryExpression (SolidityTerm UnaryOpL -> CxtS NoHole MSoliditySig (K ()) UnaryOpL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm UnaryOpL
op) (SolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
forall l. SolidityTerm l -> MSolidityTerm l
translate SolidityTerm ExpressionL
exp)

transBinOp :: F.SolidityTerm F.BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
transBinOp :: SolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
transBinOp SolidityTerm BinaryOpL
F.Exp' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ExpOp :<: f) =>
Cxt h f a BinaryOpL
Pow'
transBinOp SolidityTerm BinaryOpL
F.Mul' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Mul'
transBinOp SolidityTerm BinaryOpL
F.Div' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(DivOp :<: f) =>
Cxt h f a BinaryOpL
Div'
transBinOp SolidityTerm BinaryOpL
F.Mod' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ModOp :<: f) =>
Cxt h f a BinaryOpL
Mod'
transBinOp SolidityTerm BinaryOpL
F.Add' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Add'
transBinOp SolidityTerm BinaryOpL
F.Sub' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithBinOp :<: f) =>
Cxt h f a BinaryOpL
Sub'
transBinOp SolidityTerm BinaryOpL
F.Shl' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ShlOp :<: f) =>
Cxt h f a BinaryOpL
Shl'
transBinOp SolidityTerm BinaryOpL
F.Shr' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalShrOp :<: f) =>
Cxt h f a BinaryOpL
LogicShr'
transBinOp SolidityTerm BinaryOpL
F.Sar' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(ArithShrOp :<: f) =>
Cxt h f a BinaryOpL
ArithShr'
transBinOp SolidityTerm BinaryOpL
F.BitAnd' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitAnd'
transBinOp SolidityTerm BinaryOpL
F.BitXor' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitXor'
transBinOp SolidityTerm BinaryOpL
F.BitOr' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(BitwiseBinOp :<: f) =>
Cxt h f a BinaryOpL
BitOr'
transBinOp SolidityTerm BinaryOpL
F.LessThan' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Lt'
transBinOp SolidityTerm BinaryOpL
F.GreaterThan' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Gt'
transBinOp SolidityTerm BinaryOpL
F.LessEqual' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Lte'
transBinOp SolidityTerm BinaryOpL
F.GreaterEqual' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Gte'
transBinOp SolidityTerm BinaryOpL
F.Equal' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Eq'
transBinOp SolidityTerm BinaryOpL
F.NotEqual' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(RelationalBinOp :<: f) =>
Cxt h f a BinaryOpL
Neq'
transBinOp SolidityTerm BinaryOpL
F.And' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalBinOp :<: f) =>
Cxt h f a BinaryOpL
LogicAnd'
transBinOp SolidityTerm BinaryOpL
F.Or' = MSolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
forall a. a -> Maybe a
Just MSolidityTerm BinaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(LogicalBinOp :<: f) =>
Cxt h f a BinaryOpL
LogicOr'
transBinOp SolidityTerm BinaryOpL
_ = Maybe (MSolidityTerm BinaryOpL)
forall a. Maybe a
Nothing

transAssignOp :: F.SolidityTerm F.BinaryOpL -> Maybe (MSolidityTerm AssignOpL)
transAssignOp :: SolidityTerm BinaryOpL -> Maybe (MSolidityTerm AssignOpL)
transAssignOp SolidityTerm BinaryOpL
F.Assign' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpEquals :<: f) =>
Cxt h f a AssignOpL
AssignOpEquals'
transAssignOp SolidityTerm BinaryOpL
F.AssignAdd' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpAdd :<: f) =>
Cxt h f a AssignOpL
AssignOpAdd'
transAssignOp SolidityTerm BinaryOpL
F.AssignSub' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpSub :<: f) =>
Cxt h f a AssignOpL
AssignOpSub'
transAssignOp SolidityTerm BinaryOpL
F.AssignMul' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpMul :<: f) =>
Cxt h f a AssignOpL
AssignOpMul'
transAssignOp SolidityTerm BinaryOpL
F.AssignDiv' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpDiv :<: f) =>
Cxt h f a AssignOpL
AssignOpDiv'
transAssignOp SolidityTerm BinaryOpL
F.AssignMod' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpMod :<: f) =>
Cxt h f a AssignOpL
AssignOpMod'
transAssignOp SolidityTerm BinaryOpL
F.AssignBitAnd' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpBitAnd :<: f) =>
Cxt h f a AssignOpL
AssignOpBitAnd'
transAssignOp SolidityTerm BinaryOpL
F.AssignBitOr' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpBitOr :<: f) =>
Cxt h f a AssignOpL
AssignOpBitOr'
transAssignOp SolidityTerm BinaryOpL
F.AssignBitXor' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpBitXor :<: f) =>
Cxt h f a AssignOpL
AssignOpBitXor'
transAssignOp SolidityTerm BinaryOpL
F.AssignSar' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpArithShr :<: f) =>
Cxt h f a AssignOpL
AssignOpArithShr'
transAssignOp SolidityTerm BinaryOpL
F.AssignShr' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpLogicShr :<: f) =>
Cxt h f a AssignOpL
AssignOpLogicShr'
transAssignOp SolidityTerm BinaryOpL
F.AssignShl' = MSolidityTerm AssignOpL -> Maybe (MSolidityTerm AssignOpL)
forall a. a -> Maybe a
Just MSolidityTerm AssignOpL
forall h (f :: Fragment) (a :: * -> *) j.
(AssignOpShl :<: f) =>
Cxt h f a AssignOpL
AssignOpShl'
transAssignOp SolidityTerm BinaryOpL
_ = Maybe (MSolidityTerm AssignOpL)
forall a. Maybe a
Nothing

translateLValue
  :: F.SolidityTerm F.ExpressionL
  -> Maybe (MSolidityTerm LhsL)
translateLValue :: SolidityTerm ExpressionL -> Maybe (MSolidityTerm LhsL)
translateLValue (F.IndexExpression' SolidityTerm ExpressionL
arr SolidityTerm ExpressionL
idx) =
  MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a. a -> Maybe a
Just (MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL))
-> MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a b. (a -> b) -> a -> b
$ MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL -> MSolidityTerm LhsL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(LValue :<: f) =>
Cxt h f a ExpressionL -> Cxt h f a ExpressionL -> Cxt h f a LhsL
IndexLValue' (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
arr) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
idx)
translateLValue (F.IdentifierExpression' SolidityTerm IdentifierL
id) =
  MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a. a -> Maybe a
Just (MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL))
-> MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a b. (a -> b) -> a -> b
$ MSolidityTerm IdentL -> MSolidityTerm LhsL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(LValue :<: f) =>
Cxt h f a IdentL -> Cxt h f a LhsL
IdentifierLValue' (SolidityTerm IdentifierL -> MSolidityTerm IdentL
transIdent SolidityTerm IdentifierL
id)
translateLValue (F.MemberAccess' SolidityTerm ExpressionL
struct Cxt NoHole (Sum SoliditySig) (K ()) MemberAccessTypeL
access) =
  MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a. a -> Maybe a
Just (MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL))
-> MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a b. (a -> b) -> a -> b
$ MSolidityTerm ExpressionL
-> Cxt NoHole (Sum MSoliditySig) (K ()) MemberAccessTypeL
-> MSolidityTerm LhsL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(LValue :<: f) =>
Cxt h f a ExpressionL
-> Cxt h f a MemberAccessTypeL -> Cxt h f a LhsL
MemberAccessLValue' (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
struct) (Cxt NoHole (Sum SoliditySig) (K ()) MemberAccessTypeL
-> Cxt NoHole (Sum MSoliditySig) (K ()) MemberAccessTypeL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' Cxt NoHole (Sum SoliditySig) (K ()) MemberAccessTypeL
access)
translateLValue (F.TupleExpression' (Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
-> [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
forall l.
Cxt NoHole (Sum SoliditySig) (K ()) [l]
-> [Cxt NoHole (Sum SoliditySig) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF -> [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
exprs)) =
  MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a. a -> Maybe a
Just (MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL))
-> MSolidityTerm LhsL -> Maybe (MSolidityTerm LhsL)
forall a b. (a -> b) -> a -> b
$ Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
-> MSolidityTerm LhsL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(LValue :<: f) =>
Cxt h f a [Maybe ExpressionL] -> Cxt h f a LhsL
TupleLValue' (Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
 -> MSolidityTerm LhsL)
-> Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
-> MSolidityTerm LhsL
forall a b. (a -> b) -> a -> b
$ [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
-> Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
forall l.
Typeable l =>
[Cxt NoHole (Sum MSoliditySig) (K ()) l]
-> Cxt NoHole (Sum MSoliditySig) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
 -> Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL])
-> [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
-> Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)
 -> Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL))
-> [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
-> [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
forall a b. (a -> b) -> [a] -> [b]
map ((SolidityTerm ExpressionL -> MSolidityTerm ExpressionL)
-> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)
-> Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
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 SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression) [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
exprs
translateLValue SolidityTerm ExpressionL
_ = Maybe (MSolidityTerm LhsL)
forall a. Maybe a
Nothing

translateBinary
  :: F.SolidityTerm F.BinaryOpL
  -> F.SolidityTerm F.ExpressionL
  -> F.SolidityTerm F.ExpressionL
  -> MSolidityTerm ExpressionL
translateBinary :: SolidityTerm BinaryOpL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
translateBinary (SolidityTerm BinaryOpL -> Maybe (MSolidityTerm BinaryOpL)
transBinOp -> Just MSolidityTerm BinaryOpL
op) SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b =
  MSolidityTerm BinaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
forall h (f :: Fragment) (a :: * -> *) j.
(Operator :<: f) =>
Cxt h f a BinaryOpL
-> Cxt h f a ExpressionL
-> Cxt h f a ExpressionL
-> Cxt h f a ExpressionL
Binary' MSolidityTerm BinaryOpL
op (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
a) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
b)
translateBinary (SolidityTerm BinaryOpL -> Maybe (MSolidityTerm AssignOpL)
transAssignOp -> Just MSolidityTerm AssignOpL
op) SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b
  | Just (MSolidityTerm LhsL
lhs :: MSolidityTerm LhsL) <- SolidityTerm ExpressionL -> Maybe (MSolidityTerm LhsL)
translateLValue SolidityTerm ExpressionL
a
  = MSolidityTerm LhsL
-> MSolidityTerm AssignOpL
-> CxtS NoHole MSoliditySig (K ()) RhsL
-> MSolidityTerm ExpressionL
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 MSolidityTerm LhsL
lhs MSolidityTerm AssignOpL
op (MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (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 MSoliditySig a ExpressionL -> CxtS h MSoliditySig a RhsL
injF (MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (K ()) RhsL)
-> MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (K ()) RhsL
forall a b. (a -> b) -> a -> b
$ SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
b)
translateBinary SolidityTerm BinaryOpL
op SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b =
  CxtS NoHole MSoliditySig (K ()) BinaryOpL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
-> MSolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: 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
F.iBinaryExpression (SolidityTerm BinaryOpL -> CxtS NoHole MSoliditySig (K ()) BinaryOpL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm BinaryOpL
op) (MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (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 MSoliditySig a ExpressionL
-> CxtS h MSoliditySig a ExpressionL
injF (MSolidityTerm ExpressionL
 -> CxtS NoHole MSoliditySig (K ()) ExpressionL)
-> MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
forall a b. (a -> b) -> a -> b
$ SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
a) (MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (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 MSoliditySig a ExpressionL
-> CxtS h MSoliditySig a ExpressionL
injF (MSolidityTerm ExpressionL
 -> CxtS NoHole MSoliditySig (K ()) ExpressionL)
-> MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (K ()) ExpressionL
forall a b. (a -> b) -> a -> b
$ SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
b)

translateExpression
  :: F.SolidityTerm F.ExpressionL
  -> MSolidityTerm ExpressionL
transalteExpression :: SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
transalteExpression (F.UnaryExpression' SolidityTerm UnaryOpL
f SolidityTerm ExpressionL
a) =
  SolidityTerm UnaryOpL
-> SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateUnary SolidityTerm UnaryOpL
f SolidityTerm ExpressionL
a
transalteExpression (F.BinaryExpression' SolidityTerm BinaryOpL
f SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b) =
  SolidityTerm BinaryOpL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
translateBinary SolidityTerm BinaryOpL
f SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b
transalteExpression (F.ConditionalExpression' SolidityTerm ExpressionL
cond SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b) =
  Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
forall h (f :: Fragment) (a :: * -> *) j.
(Operator :<: f) =>
Cxt h f a TernaryOpL
-> Cxt h f a ExpressionL
-> Cxt h f a ExpressionL
-> Cxt h f a ExpressionL
-> Cxt h f a ExpressionL
Ternary' Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(CondTernaryOp :<: f) =>
Cxt h f a TernaryOpL
ITE' (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
cond) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
a) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression SolidityTerm ExpressionL
b)
translateExpression :: SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateExpression =
  SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate'

instance Trans F.Expression where
  trans :: forall l.
Expression (Cxt NoHole (Sum SoliditySig) (K ())) l
-> MSolidityTerm l
trans (F.UnaryExpression SolidityTerm UnaryOpL
f SolidityTerm ExpressionL
a) =
    MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (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 MSoliditySig a ExpressionL -> CxtS h MSoliditySig a l
injF (MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (K ()) l)
-> MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (K ()) l
forall a b. (a -> b) -> a -> b
$ SolidityTerm UnaryOpL
-> SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
translateUnary SolidityTerm UnaryOpL
f SolidityTerm ExpressionL
a
  trans (F.BinaryExpression SolidityTerm BinaryOpL
f SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b) =
    MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (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 MSoliditySig a ExpressionL -> CxtS h MSoliditySig a l
injF (MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (K ()) l)
-> MSolidityTerm ExpressionL -> CxtS NoHole MSoliditySig (K ()) l
forall a b. (a -> b) -> a -> b
$ SolidityTerm BinaryOpL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
translateBinary SolidityTerm BinaryOpL
f SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b
  trans (F.ConditionalExpression SolidityTerm ExpressionL
cond SolidityTerm ExpressionL
a SolidityTerm ExpressionL
b) =
    Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> CxtS NoHole MSoliditySig (K ()) l
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Operator :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a TernaryOpL
-> CxtS h fs a ExpressionL
-> CxtS h fs a ExpressionL
-> CxtS h fs a ExpressionL
-> CxtS h fs a j
iTernary Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
forall h (f :: Fragment) (a :: * -> *) j.
(CondTernaryOp :<: f) =>
Cxt h f a TernaryOpL
ITE' (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm ExpressionL
cond) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm ExpressionL
a) (SolidityTerm ExpressionL -> MSolidityTerm ExpressionL
forall l l'.
InjF MSoliditySig l l' =>
SolidityTerm l -> MSolidityTerm l'
translate' SolidityTerm ExpressionL
b)
  trans Expression (Cxt NoHole (Sum SoliditySig) (K ())) l
x =
    Expression (Cxt NoHole (Sum SoliditySig) (K ())) l
-> CxtS NoHole MSoliditySig (K ()) l
forall (f :: Fragment) l.
(HFunctor f, f :-<: MSoliditySig, f :-<: SoliditySig) =>
f (Cxt NoHole (Sum SoliditySig) (K ())) l -> MSolidityTerm l
transDefault Expression (Cxt NoHole (Sum SoliditySig) (K ())) l
x

------------------------------------------------------------------------------------
---------------- Reverse translation: IPS to modularized syntax  -------------------
------------------------------------------------------------------------------------

--------------------------------
------------- Top-level untranslate
--------------------------------

------ Class (contains top-level function on sigs)

class Untrans f where
  untrans :: f MSolidityTerm l -> F.SolidityTerm l

------ Default and standard cases

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

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

do ipsNames <- sumToNames ''MSoliditySig
   modNames <- sumToNames ''F.SoliditySig
   let targTs = map ConT $ (ipsNames \\ modNames) \\ [ ''IdentIsIdentifier, ''ExpressionIsSolExp, ''SolExpIsExpression ]
   return $ makeDefaultInstances targTs ''Untrans 'untrans (VarE 'untransError)

untransDefault :: (HFunctor f, f :-<: F.SoliditySig) => f MSolidityTerm l -> F.SolidityTerm l
untransDefault :: forall (f :: Fragment) l.
(HFunctor f, f :-<: SoliditySig) =>
f (Cxt NoHole (Sum MSoliditySig) (K ())) l -> SolidityTerm l
untransDefault = f (Cxt NoHole (Sum SoliditySig) (K ())) l
-> Cxt NoHole (Sum SoliditySig) (K ()) l
f (Cxt NoHole (Sum SoliditySig) (K ()))
:-> Cxt NoHole (Sum SoliditySig) (K ())
forall (g :: Fragment) (f :: Fragment) h (a :: * -> *).
(g :<: f) =>
g (Cxt h f a) :-> Cxt h f a
inject (f (Cxt NoHole (Sum SoliditySig) (K ())) l
 -> Cxt NoHole (Sum SoliditySig) (K ()) l)
-> (f (Cxt NoHole (Sum MSoliditySig) (K ())) l
    -> f (Cxt NoHole (Sum SoliditySig) (K ())) l)
-> f (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> Cxt NoHole (Sum SoliditySig) (K ()) l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Cxt NoHole (Sum MSoliditySig) (K ())
 :-> Cxt NoHole (Sum SoliditySig) (K ()))
-> f (Cxt NoHole (Sum MSoliditySig) (K ()))
   :-> f (Cxt NoHole (Sum SoliditySig) (K ()))
forall (f :: * -> *) (g :: * -> *). (f :-> g) -> f f :-> f g
forall (h :: Fragment) (f :: * -> *) (g :: * -> *).
HFunctor h =>
(f :-> g) -> h f :-> h g
hfmap MSolidityTerm i -> SolidityTerm i
Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate

instance {-# OVERLAPPABLE #-} (HFunctor f, f :-<: F.SoliditySig) => Untrans f where
  untrans :: forall l.
f (Cxt NoHole (Sum MSoliditySig) (K ())) l -> SolidityTerm l
untrans = f (Cxt NoHole (Sum MSoliditySig) (K ())) l -> SolidityTerm l
forall (f :: Fragment) l.
(HFunctor f, f :-<: SoliditySig) =>
f (Cxt NoHole (Sum MSoliditySig) (K ())) l -> SolidityTerm l
untransDefault

------ Top level function on terms

-- Must define this after template Haskell block
untranslate :: MSolidityTerm l -> F.SolidityTerm l
untranslate :: Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate = Sum MSoliditySig (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> SolidityTerm l
forall l.
Sum MSoliditySig (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> SolidityTerm l
forall (f :: Fragment) l.
Untrans f =>
f (Cxt NoHole (Sum MSoliditySig) (K ())) l -> SolidityTerm l
untrans (Sum MSoliditySig (Cxt NoHole (Sum MSoliditySig) (K ())) l
 -> SolidityTerm l)
-> (MSolidityTerm l
    -> Sum MSoliditySig (Cxt NoHole (Sum MSoliditySig) (K ())) l)
-> MSolidityTerm l
-> SolidityTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MSolidityTerm l
-> Sum MSoliditySig (Cxt NoHole (Sum MSoliditySig) (K ())) l
forall (f :: Fragment) t. HFix f t -> f (HFix f) t
unTerm

untranslate' :: InjF MSoliditySig l l' => MSolidityTerm l' -> F.SolidityTerm l
untranslate' :: forall l l'.
InjF MSoliditySig l l' =>
MSolidityTerm l' -> SolidityTerm l
untranslate' = MSolidityTerm l -> SolidityTerm l
Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate (MSolidityTerm l -> SolidityTerm l)
-> (MSolidityTerm l' -> MSolidityTerm l)
-> MSolidityTerm l'
-> SolidityTerm l
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MSolidityTerm l' -> MSolidityTerm l
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF

--------------------------------
------------- Per-fragment instances
--------------------------------

-------- Identifiers

untransIdent :: MSolidityTerm IdentL -> F.SolidityTerm F.IdentifierL
untransIdent :: MSolidityTerm IdentL -> SolidityTerm IdentifierL
untransIdent (Ident' String
s) = Text -> SolidityTerm IdentifierL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Identifier :-<: fs, InjF fs IdentifierL j) =>
Text -> CxtS h fs a j
F.iIdentifier (String -> Text
Text.pack String
s)

instance {-# OVERLAPPING #-} Untrans IdentIsIdentifier where
  untrans :: forall l.
IdentIsIdentifier (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> SolidityTerm l
untrans (IdentIsIdentifier MSolidityTerm IdentL
n) = MSolidityTerm IdentL -> SolidityTerm IdentifierL
untransIdent MSolidityTerm IdentL
n

untransUnaryOp :: MSolidityTerm UnaryOpL -> F.SolidityTerm F.UnaryOpL
untransUnaryOp :: MSolidityTerm UnaryOpL -> SolidityTerm UnaryOpL
untransUnaryOp MSolidityTerm UnaryOpL
UnaryMinus' = SolidityTerm UnaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(UnaryOp :<: f) =>
Cxt h f a UnaryOpL
F.UPreSub'
untransUnaryOp MSolidityTerm UnaryOpL
Complement' = SolidityTerm UnaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(UnaryOp :<: f) =>
Cxt h f a UnaryOpL
F.UPreBitNot'
untransUnaryOp MSolidityTerm UnaryOpL
Not' = SolidityTerm UnaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(UnaryOp :<: f) =>
Cxt h f a UnaryOpL
F.UPreNot'

untransUnary
  :: MSolidityTerm UnaryOpL
  -> MSolidityTerm ExpressionL
  -> F.SolidityTerm F.ExpressionL
untransUnary :: MSolidityTerm UnaryOpL
-> MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransUnary MSolidityTerm UnaryOpL
op MSolidityTerm ExpressionL
e = SolidityTerm UnaryOpL
-> SolidityTerm ExpressionL -> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a UnaryOpL -> CxtS h fs a ExpressionL -> CxtS h fs a j
F.iUnaryExpression (MSolidityTerm UnaryOpL -> SolidityTerm UnaryOpL
untransUnaryOp MSolidityTerm UnaryOpL
op) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
e)

untransBinOp :: MSolidityTerm BinaryOpL -> F.SolidityTerm F.BinaryOpL
untransBinOp :: MSolidityTerm BinaryOpL -> SolidityTerm BinaryOpL
untransBinOp MSolidityTerm BinaryOpL
Pow' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Exp'
untransBinOp MSolidityTerm BinaryOpL
Mul' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Mul'
untransBinOp MSolidityTerm BinaryOpL
Div' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Div'
untransBinOp MSolidityTerm BinaryOpL
Mod' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Mod'
untransBinOp MSolidityTerm BinaryOpL
Add' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Add'
untransBinOp MSolidityTerm BinaryOpL
Sub' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Sub'
untransBinOp MSolidityTerm BinaryOpL
Shl'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Shl'
untransBinOp MSolidityTerm BinaryOpL
LogicShr' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Shr'
untransBinOp MSolidityTerm BinaryOpL
ArithShr' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Sar'
untransBinOp MSolidityTerm BinaryOpL
BitAnd' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.BitAnd'
untransBinOp MSolidityTerm BinaryOpL
BitXor' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.BitXor'
untransBinOp MSolidityTerm BinaryOpL
BitOr'  = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.BitOr'
untransBinOp MSolidityTerm BinaryOpL
Lt'  = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.LessThan'
untransBinOp MSolidityTerm BinaryOpL
Gt'  = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.GreaterThan'
untransBinOp MSolidityTerm BinaryOpL
Lte' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.LessEqual'
untransBinOp MSolidityTerm BinaryOpL
Gte' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.GreaterEqual'
untransBinOp MSolidityTerm BinaryOpL
Eq'  = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Equal'
untransBinOp MSolidityTerm BinaryOpL
Neq' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.NotEqual'
untransBinOp MSolidityTerm BinaryOpL
LogicAnd' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.And'
untransBinOp MSolidityTerm BinaryOpL
LogicOr'  = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Or'

untransBinary
  :: MSolidityTerm BinaryOpL
  -> MSolidityTerm ExpressionL
  -> MSolidityTerm ExpressionL
  -> F.SolidityTerm F.ExpressionL
untransBinary :: MSolidityTerm BinaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> SolidityTerm ExpressionL
untransBinary MSolidityTerm BinaryOpL
op MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b = SolidityTerm BinaryOpL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: 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
F.iBinaryExpression (MSolidityTerm BinaryOpL -> SolidityTerm BinaryOpL
untransBinOp MSolidityTerm BinaryOpL
op) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
a) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
b)

untransTernary
  :: MSolidityTerm TernaryOpL
  -> MSolidityTerm ExpressionL
  -> MSolidityTerm ExpressionL
  -> MSolidityTerm ExpressionL
  -> F.SolidityTerm F.ExpressionL
untransTernary :: Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> SolidityTerm ExpressionL
untransTernary Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
ITE' MSolidityTerm ExpressionL
cond MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b =
  SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a ExpressionL
-> CxtS h fs a ExpressionL
-> CxtS h fs a ExpressionL
-> CxtS h fs a j
F.iConditionalExpression (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
cond) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
a) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
b)

untransExpression :: MSolidityTerm ExpressionL -> F.SolidityTerm F.ExpressionL
untransExpression :: MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression (Unary' MSolidityTerm UnaryOpL
op MSolidityTerm ExpressionL
e) = MSolidityTerm UnaryOpL
-> MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransUnary MSolidityTerm UnaryOpL
op MSolidityTerm ExpressionL
e
untransExpression (Binary' MSolidityTerm BinaryOpL
op MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b) = MSolidityTerm BinaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> SolidityTerm ExpressionL
untransBinary MSolidityTerm BinaryOpL
op MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b
untransExpression (Ternary' Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
op MSolidityTerm ExpressionL
cond MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b) = Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> MSolidityTerm ExpressionL
-> SolidityTerm ExpressionL
untransTernary Cxt NoHole (Sum MSoliditySig) (K ()) TernaryOpL
op MSolidityTerm ExpressionL
cond MSolidityTerm ExpressionL
a MSolidityTerm ExpressionL
b
untransExpression (AssignIsExpression' Cxt NoHole (Sum MSoliditySig) (K ()) AssignL
e) = Cxt NoHole (Sum MSoliditySig) (K ()) AssignL
-> SolidityTerm ExpressionL
untransAssign Cxt NoHole (Sum MSoliditySig) (K ()) AssignL
e
untransExpression (SolExpIsExpression' CxtS NoHole MSoliditySig (K ()) ExpressionL
e) = CxtS NoHole MSoliditySig (K ()) ExpressionL
-> SolidityTerm ExpressionL
Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate CxtS NoHole MSoliditySig (K ()) ExpressionL
e

instance {-# OVERLAPPING #-} Untrans ExpressionIsSolExp where
  untrans :: forall l.
ExpressionIsSolExp (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> SolidityTerm l
untrans (ExpressionIsSolExp MSolidityTerm ExpressionL
e) = MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
e

untransSolExp :: MSolidityTerm F.ExpressionL -> F.SolidityTerm ExpressionL
untransSolExp :: CxtS NoHole MSoliditySig (K ()) ExpressionL
-> SolidityTerm ExpressionL
untransSolExp (ExpressionIsSolExp' MSolidityTerm ExpressionL
e) = MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate MSolidityTerm ExpressionL
e

instance {-# OVERLAPPING #-} Untrans SolExpIsExpression where
  untrans :: forall l.
SolExpIsExpression (Cxt NoHole (Sum MSoliditySig) (K ())) l
-> SolidityTerm l
untrans (SolExpIsExpression CxtS NoHole MSoliditySig (K ()) ExpressionL
e) = CxtS NoHole MSoliditySig (K ()) ExpressionL
-> SolidityTerm ExpressionL
untransSolExp CxtS NoHole MSoliditySig (K ()) ExpressionL
e

untransLValue :: MSolidityTerm LhsL -> F.SolidityTerm F.ExpressionL
untransLValue :: MSolidityTerm LhsL -> SolidityTerm ExpressionL
untransLValue (IndexLValue' MSolidityTerm ExpressionL
arr MSolidityTerm ExpressionL
idx) =
  SolidityTerm ExpressionL
-> SolidityTerm ExpressionL -> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a ExpressionL -> CxtS h fs a ExpressionL -> CxtS h fs a j
F.iIndexExpression (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
arr) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
idx)
untransLValue (IdentifierLValue' MSolidityTerm IdentL
ident) =
  SolidityTerm IdentifierL -> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a IdentifierL -> CxtS h fs a j
F.iIdentifierExpression (SolidityTerm IdentifierL -> SolidityTerm ExpressionL)
-> SolidityTerm IdentifierL -> SolidityTerm ExpressionL
forall a b. (a -> b) -> a -> b
$ MSolidityTerm IdentL -> SolidityTerm IdentifierL
untransIdent MSolidityTerm IdentL
ident
untransLValue (MemberAccessLValue' MSolidityTerm ExpressionL
struct Cxt NoHole (Sum MSoliditySig) (K ()) MemberAccessTypeL
mem) =
  SolidityTerm ExpressionL
-> Cxt NoHole (Sum SoliditySig) (K ()) MemberAccessTypeL
-> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a ExpressionL
-> CxtS h fs a MemberAccessTypeL -> CxtS h fs a j
F.iMemberAccess (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
struct) (Cxt NoHole (Sum MSoliditySig) (K ()) MemberAccessTypeL
-> Cxt NoHole (Sum SoliditySig) (K ()) MemberAccessTypeL
Cxt NoHole (Sum MSoliditySig) (K ())
:-> Cxt NoHole (Sum SoliditySig) (K ())
untranslate Cxt NoHole (Sum MSoliditySig) (K ()) MemberAccessTypeL
mem)
untransLValue (TupleLValue' (Cxt NoHole (Sum MSoliditySig) (K ()) [Maybe ExpressionL]
-> [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
forall l.
Cxt NoHole (Sum MSoliditySig) (K ()) [l]
-> [Cxt NoHole (Sum MSoliditySig) (K ()) l]
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF -> [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
exprs)) =
  Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
-> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: fs, InjF fs ExpressionL j) =>
CxtS h fs a [Maybe ExpressionL] -> CxtS h fs a j
F.iTupleExpression (Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
 -> SolidityTerm ExpressionL)
-> Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
-> SolidityTerm ExpressionL
forall a b. (a -> b) -> a -> b
$ [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
-> Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
forall l.
Typeable l =>
[Cxt NoHole (Sum SoliditySig) (K ()) l]
-> Cxt NoHole (Sum SoliditySig) (K ()) [l]
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF ([Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
 -> Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL])
-> [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
-> Cxt NoHole (Sum SoliditySig) (K ()) [Maybe ExpressionL]
forall a b. (a -> b) -> a -> b
$ (Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
 -> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL))
-> [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
-> [Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)]
forall a b. (a -> b) -> [a] -> [b]
map (Maybe (SolidityTerm ExpressionL)
-> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)
forall l.
Typeable l =>
Maybe (Cxt NoHole (Sum SoliditySig) (K ()) l)
-> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe l)
forall (f :: * -> *) (e :: * -> *) l.
(InsertF f e, Typeable l) =>
f (e l) -> e (f l)
insertF (Maybe (SolidityTerm ExpressionL)
 -> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL))
-> (Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
    -> Maybe (SolidityTerm ExpressionL))
-> Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
-> Cxt NoHole (Sum SoliditySig) (K ()) (Maybe ExpressionL)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL)
-> Maybe (MSolidityTerm ExpressionL)
-> Maybe (SolidityTerm ExpressionL)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression (Maybe (MSolidityTerm ExpressionL)
 -> Maybe (SolidityTerm ExpressionL))
-> (Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
    -> Maybe (MSolidityTerm ExpressionL))
-> Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
-> Maybe (SolidityTerm ExpressionL)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)
-> Maybe (MSolidityTerm ExpressionL)
forall l.
Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe l)
-> Maybe (Cxt NoHole (Sum MSoliditySig) (K ()) l)
forall (f :: * -> *) (e :: * -> *) l.
ExtractF f e =>
e (f l) -> f (e l)
extractF) [Cxt NoHole (Sum MSoliditySig) (K ()) (Maybe ExpressionL)]
exprs

untransAssignOp :: MSolidityTerm AssignOpL -> F.SolidityTerm F.BinaryOpL
untransAssignOp :: MSolidityTerm AssignOpL -> SolidityTerm BinaryOpL
untransAssignOp MSolidityTerm AssignOpL
AssignOpEquals'   = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.Assign'
untransAssignOp MSolidityTerm AssignOpL
AssignOpAdd'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignAdd'
untransAssignOp MSolidityTerm AssignOpL
AssignOpSub'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignSub'
untransAssignOp MSolidityTerm AssignOpL
AssignOpMul'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignMul'
untransAssignOp MSolidityTerm AssignOpL
AssignOpDiv'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignDiv'
untransAssignOp MSolidityTerm AssignOpL
AssignOpMod'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignMod'
untransAssignOp MSolidityTerm AssignOpL
AssignOpBitAnd'   = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignBitAnd'
untransAssignOp MSolidityTerm AssignOpL
AssignOpBitOr'    = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignBitOr'
untransAssignOp MSolidityTerm AssignOpL
AssignOpBitXor'   = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignBitXor'
untransAssignOp MSolidityTerm AssignOpL
AssignOpArithShr' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignSar'
untransAssignOp MSolidityTerm AssignOpL
AssignOpLogicShr' = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignShr'
untransAssignOp MSolidityTerm AssignOpL
AssignOpShl'      = SolidityTerm BinaryOpL
forall {k} h (f :: Fragment) (a :: * -> *) (j :: k).
(BinaryOp :<: f) =>
Cxt h f a BinaryOpL
F.AssignShl'

untransAssign :: MSolidityTerm AssignL -> F.SolidityTerm F.ExpressionL
untransAssign :: Cxt NoHole (Sum MSoliditySig) (K ()) AssignL
-> SolidityTerm ExpressionL
untransAssign (Assign' MSolidityTerm LhsL
lhs MSolidityTerm AssignOpL
op CxtS NoHole MSoliditySig (K ()) RhsL
rhs)
    | MSolidityTerm ExpressionL
arg :: MSolidityTerm ExpressionL <- CxtS NoHole MSoliditySig (K ()) RhsL -> MSolidityTerm ExpressionL
forall (fs :: [Fragment]) l l' h (a :: * -> *).
InjF fs l l' =>
CxtS h fs a l' -> CxtS h fs a l
fromProjF CxtS NoHole MSoliditySig (K ()) RhsL
rhs
    = SolidityTerm BinaryOpL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
-> SolidityTerm ExpressionL
forall h (fs :: [Fragment]) (a :: * -> *) j.
(Expression :-<: 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
F.iBinaryExpression (MSolidityTerm AssignOpL -> SolidityTerm BinaryOpL
untransAssignOp MSolidityTerm AssignOpL
op) (MSolidityTerm LhsL -> SolidityTerm ExpressionL
untransLValue MSolidityTerm LhsL
lhs) (MSolidityTerm ExpressionL -> SolidityTerm ExpressionL
untransExpression MSolidityTerm ExpressionL
arg)