{-|
Module      : IRTS.Portable
Description : Serialise Idris' IR to JSON.

License     : BSD3
Maintainer  : The Idris Community.
-}
{-# LANGUAGE FlexibleInstances, OverloadedStrings, TypeSynonymInstances #-}
module IRTS.Portable (writePortable) where

import Idris.Core.CaseTree
import Idris.Core.Evaluate
import Idris.Core.TT
import IRTS.Bytecode
import IRTS.CodegenCommon
import IRTS.Defunctionalise
import IRTS.Simplified

import Data.Aeson
import qualified Data.ByteString.Lazy as B
import System.IO

data CodegenFile = CGFile {
    CodegenFile -> String
fileType :: String,
    CodegenFile -> Int
version :: Int,
    CodegenFile -> CodegenInfo
cgInfo :: CodegenInfo
}

-- Update the version when the format changes
formatVersion :: Int
formatVersion :: Int
formatVersion = 3

writePortable :: Handle -> CodegenInfo -> IO ()
writePortable :: Handle -> CodegenInfo -> IO ()
writePortable file :: Handle
file ci :: CodegenInfo
ci = do
    let json :: ByteString
json = CodegenFile -> ByteString
forall a. ToJSON a => a -> ByteString
encode (CodegenFile -> ByteString) -> CodegenFile -> ByteString
forall a b. (a -> b) -> a -> b
$ String -> Int -> CodegenInfo -> CodegenFile
CGFile "idris-codegen" Int
formatVersion CodegenInfo
ci
    Handle -> ByteString -> IO ()
B.hPut Handle
file ByteString
json

instance ToJSON CodegenFile where
    toJSON :: CodegenFile -> Value
toJSON (CGFile ft :: String
ft v :: Int
v ci :: CodegenInfo
ci) = [Pair] -> Value
object ["file-type" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
ft,
                                      "version" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
v,
                                      "codegen-info" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= CodegenInfo -> Value
forall a. ToJSON a => a -> Value
toJSON CodegenInfo
ci]

instance ToJSON CodegenInfo where
    toJSON :: CodegenInfo -> Value
toJSON ci :: CodegenInfo
ci = [Pair] -> Value
object ["output-file" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> String
outputFile CodegenInfo
ci),
                        "includes" Text -> [String] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [String]
includes CodegenInfo
ci),
                        "import-dirs" Text -> [String] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [String]
importDirs CodegenInfo
ci),
                        "compile-objs" Text -> [String] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [String]
compileObjs CodegenInfo
ci),
                        "compile-libs" Text -> [String] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [String]
compileLibs CodegenInfo
ci),
                        "compiler-flags" Text -> [String] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [String]
compilerFlags CodegenInfo
ci),
                        "interfaces" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> Bool
interfaces CodegenInfo
ci),
                        "exports" Text -> [ExportIFace] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [ExportIFace]
exportDecls CodegenInfo
ci),
                        "lift-decls" Text -> [(Name, LDecl)] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [(Name, LDecl)]
liftDecls CodegenInfo
ci),
                        "defun-decls" Text -> [(Name, DDecl)] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [(Name, DDecl)]
defunDecls CodegenInfo
ci),
                        "simple-decls" Text -> [(Name, SDecl)] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [(Name, SDecl)]
simpleDecls CodegenInfo
ci),
                        "bytecode" Text -> [(Name, [BC])] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (((Name, SDecl) -> (Name, [BC]))
-> [(Name, SDecl)] -> [(Name, [BC])]
forall a b. (a -> b) -> [a] -> [b]
map (Name, SDecl) -> (Name, [BC])
toBC (CodegenInfo -> [(Name, SDecl)]
simpleDecls CodegenInfo
ci)),
                        "tt-decls" Text -> [(Name, TTDecl)] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CodegenInfo -> [(Name, TTDecl)]
ttDecls CodegenInfo
ci)]

instance ToJSON Name where
    toJSON :: Name -> Value
toJSON n :: Name
n = String -> Value
forall a. ToJSON a => a -> Value
toJSON (String -> Value) -> String -> Value
forall a b. (a -> b) -> a -> b
$ Name -> String
showCG Name
n

instance ToJSON ExportIFace where
    toJSON :: ExportIFace -> Value
toJSON (Export n :: Name
n f :: String
f xs :: [Export]
xs) = [Pair] -> Value
object ["ffi-desc" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
n,
                                     "interface-file" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
f,
                                     "exports" Text -> [Export] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Export]
xs]

instance ToJSON FDesc where
    toJSON :: FDesc -> Value
toJSON (FCon n :: Name
n) = [Pair] -> Value
object ["FCon" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
n]
    toJSON (FStr s :: String
s) = [Pair] -> Value
object ["FStr" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]
    toJSON (FDesc
FUnknown) = [Pair] -> Value
object ["FUnknown" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (FIO fd :: FDesc
fd) = [Pair] -> Value
object ["FIO" Text -> FDesc -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= FDesc
fd]
    toJSON (FApp n :: Name
n xs :: [FDesc]
xs) = [Pair] -> Value
object ["FApp" Text -> (Name, [FDesc]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
n, [FDesc]
xs)]

instance ToJSON Export where
    toJSON :: Export -> Value
toJSON (ExportData fd :: FDesc
fd) = [Pair] -> Value
object ["ExportData" Text -> FDesc -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= FDesc
fd]
    toJSON (ExportFun n :: Name
n dsc :: FDesc
dsc ret :: FDesc
ret args :: [FDesc]
args) = [Pair] -> Value
object ["ExportFun" Text -> (Name, FDesc, FDesc, [FDesc]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
n, FDesc
dsc, FDesc
ret, [FDesc]
args)]

instance ToJSON LDecl where
    toJSON :: LDecl -> Value
toJSON (LFun opts :: [LOpt]
opts name :: Name
name args :: [Name]
args def :: LExp
def) = [Pair] -> Value
object ["LFun" Text -> ([LOpt], Name, [Name], LExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ([LOpt]
opts, Name
name, [Name]
args, LExp
def)]
    toJSON (LConstructor name :: Name
name tag :: Int
tag ar :: Int
ar) = [Pair] -> Value
object ["LConstructor" Text -> (Name, Int, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, Int
tag, Int
ar)]

instance ToJSON LOpt where
    toJSON :: LOpt -> Value
toJSON Inline = Text -> Value
String "Inline"
    toJSON NoInline = Text -> Value
String "NoInline"

instance ToJSON LExp where
    toJSON :: LExp -> Value
toJSON (LV lv :: Name
lv) = [Pair] -> Value
object ["LV" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
lv]
    toJSON (LApp tail :: Bool
tail exp :: LExp
exp args :: [LExp]
args) = [Pair] -> Value
object ["LApp" Text -> (Bool, LExp, [LExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
tail, LExp
exp, [LExp]
args)]
    toJSON (LLazyApp name :: Name
name exps :: [LExp]
exps) = [Pair] -> Value
object ["LLazyApp" Text -> (Name, [LExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, [LExp]
exps)]
    toJSON (LLazyExp exp :: LExp
exp) = [Pair] -> Value
object ["LLazyExp" Text -> LExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= LExp
exp]
    toJSON (LForce exp :: LExp
exp) = [Pair] -> Value
object ["LForce" Text -> LExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= LExp
exp]
    toJSON (LLet name :: Name
name a :: LExp
a b :: LExp
b) = [Pair] -> Value
object ["LLet" Text -> (Name, LExp, LExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, LExp
a, LExp
b)]
    toJSON (LLam args :: [Name]
args exp :: LExp
exp) = [Pair] -> Value
object ["LLam" Text -> ([Name], LExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ([Name]
args, LExp
exp)]
    toJSON (LProj exp :: LExp
exp i :: Int
i) = [Pair] -> Value
object ["LProj" Text -> (LExp, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (LExp
exp, Int
i)]
    toJSON (LCon lv :: Maybe Name
lv i :: Int
i n :: Name
n exps :: [LExp]
exps) = [Pair] -> Value
object ["LCon" Text -> (Maybe Name, Int, Name, [LExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Maybe Name
lv, Int
i, Name
n, [LExp]
exps)]
    toJSON (LCase ct :: CaseType
ct exp :: LExp
exp alts :: [LAlt]
alts) = [Pair] -> Value
object ["LCase" Text -> (CaseType, LExp, [LAlt]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CaseType
ct, LExp
exp, [LAlt]
alts)]
    toJSON (LConst c :: Const
c) = [Pair] -> Value
object ["LConst" Text -> Const -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Const
c]
    toJSON (LForeign fd :: FDesc
fd ret :: FDesc
ret exps :: [(FDesc, LExp)]
exps) = [Pair] -> Value
object ["LForeign" Text -> (FDesc, FDesc, [(FDesc, LExp)]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (FDesc
fd, FDesc
ret, [(FDesc, LExp)]
exps)]
    toJSON (LOp prim :: PrimFn
prim exps :: [LExp]
exps) = [Pair] -> Value
object ["LOp" Text -> (PrimFn, [LExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (PrimFn
prim, [LExp]
exps)]
    toJSON LNothing = [Pair] -> Value
object ["LNothing" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (LError s :: String
s) = [Pair] -> Value
object ["LError" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]

instance ToJSON LVar where
    toJSON :: LVar -> Value
toJSON (Loc i :: Int
i) = [Pair] -> Value
object ["Loc" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (Glob n :: Name
n) = [Pair] -> Value
object ["Glob" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
n]

instance ToJSON CaseType where
    toJSON :: CaseType -> Value
toJSON Updatable = Text -> Value
String "Updatable"
    toJSON Shared = Text -> Value
String "Shared"

instance ToJSON LAlt where
    toJSON :: LAlt -> Value
toJSON (LConCase i :: Int
i n :: Name
n ns :: [Name]
ns exp :: LExp
exp) = [Pair] -> Value
object ["LConCase" Text -> (Int, Name, [Name], LExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
i, Name
n, [Name]
ns, LExp
exp)]
    toJSON (LConstCase c :: Const
c exp :: LExp
exp) = [Pair] -> Value
object ["LConstCase" Text -> (Const, LExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Const
c, LExp
exp)]
    toJSON (LDefaultCase exp :: LExp
exp) = [Pair] -> Value
object ["LDefaultCase" Text -> LExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= LExp
exp]

instance ToJSON Const where
    toJSON :: Const -> Value
toJSON (I i :: Int
i) = [Pair] -> Value
object ["int" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (BI i :: Integer
i) = [Pair] -> Value
object ["bigint" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Integer -> String
forall a. Show a => a -> String
show Integer
i)]
    toJSON (Fl d :: Double
d) = [Pair] -> Value
object ["double" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Double
d]
    toJSON (Ch c :: Char
c) = [Pair] -> Value
object ["char" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Char -> String
forall a. Show a => a -> String
show Char
c)]
    toJSON (Str s :: String
s) = [Pair] -> Value
object ["string" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]
    toJSON (B8 b :: Word8
b) = [Pair] -> Value
object ["bits8" Text -> Word8 -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Word8
b]
    toJSON (B16 b :: Word16
b) = [Pair] -> Value
object ["bits16" Text -> Word16 -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Word16
b]
    toJSON (B32 b :: Word32
b) = [Pair] -> Value
object ["bits32" Text -> Word32 -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Word32
b]
    toJSON (B64 b :: Word64
b) = [Pair] -> Value
object ["bits64" Text -> Word64 -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Word64
b]
    toJSON (AType at :: ArithTy
at) = [Pair] -> Value
object ["atype" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
at]
    toJSON StrType = [Pair] -> Value
object ["strtype" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON WorldType = [Pair] -> Value
object ["worldtype" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON TheWorld = [Pair] -> Value
object ["theworld" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON VoidType = [Pair] -> Value
object ["voidtype" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON Forgot = [Pair] -> Value
object ["forgot" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]

instance ToJSON ArithTy where
    toJSON :: ArithTy -> Value
toJSON (ATInt it :: IntTy
it) = [Pair] -> Value
object ["ATInt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
it]
    toJSON ATFloat = [Pair] -> Value
object ["ATFloat" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]

instance ToJSON IntTy where
    toJSON :: IntTy -> Value
toJSON it :: IntTy
it = String -> Value
forall a. ToJSON a => a -> Value
toJSON (String -> Value) -> String -> Value
forall a b. (a -> b) -> a -> b
$ IntTy -> String
intTyName IntTy
it

instance ToJSON PrimFn where
    toJSON :: PrimFn -> Value
toJSON (LPlus aty :: ArithTy
aty) = [Pair] -> Value
object ["LPlus" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LMinus aty :: ArithTy
aty) = [Pair] -> Value
object ["LMinus" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LTimes aty :: ArithTy
aty) = [Pair] -> Value
object ["LTimes" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LUDiv aty :: IntTy
aty) = [Pair] -> Value
object ["LUDiv" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
aty]
    toJSON (LSDiv aty :: ArithTy
aty) = [Pair] -> Value
object ["LSDiv" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LURem ity :: IntTy
ity) = [Pair] -> Value
object ["LURem" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LSRem aty :: ArithTy
aty) = [Pair] -> Value
object ["LSRem" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LAnd ity :: IntTy
ity) = [Pair] -> Value
object ["LAnd" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LOr ity :: IntTy
ity) = [Pair] -> Value
object ["LOr" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LXOr ity :: IntTy
ity) = [Pair] -> Value
object ["LXOr" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LCompl ity :: IntTy
ity) = [Pair] -> Value
object ["LCompl" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LSHL ity :: IntTy
ity) = [Pair] -> Value
object ["LSHL" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LLSHR ity :: IntTy
ity) = [Pair] -> Value
object ["LLSHR" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LASHR ity :: IntTy
ity) = [Pair] -> Value
object ["LASHR" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LEq aty :: ArithTy
aty) = [Pair] -> Value
object ["LEq" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LLt ity :: IntTy
ity) = [Pair] -> Value
object ["LLt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LLe ity :: IntTy
ity) = [Pair] -> Value
object ["LLe" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LGt ity :: IntTy
ity) = [Pair] -> Value
object ["LGt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LGe ity :: IntTy
ity) = [Pair] -> Value
object ["LGe" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LSLt aty :: ArithTy
aty) = [Pair] -> Value
object ["LSLt" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LSLe aty :: ArithTy
aty) = [Pair] -> Value
object ["LSLe" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LSGt aty :: ArithTy
aty) = [Pair] -> Value
object ["LSGt" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LSGe aty :: ArithTy
aty) = [Pair] -> Value
object ["LSGe" Text -> ArithTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ArithTy
aty]
    toJSON (LZExt from :: IntTy
from to :: IntTy
to) = [Pair] -> Value
object ["LZExt" Text -> (IntTy, IntTy) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (IntTy
from, IntTy
to)]
    toJSON (LSExt from :: IntTy
from to :: IntTy
to) = [Pair] -> Value
object ["LSExt" Text -> (IntTy, IntTy) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (IntTy
from, IntTy
to)]
    toJSON (LTrunc from :: IntTy
from to :: IntTy
to) = [Pair] -> Value
object ["LTrunc" Text -> (IntTy, IntTy) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (IntTy
from, IntTy
to)]
    toJSON LStrConcat = [Pair] -> Value
object ["LStrConcat" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrLt = [Pair] -> Value
object ["LStrLt" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrEq = [Pair] -> Value
object ["LStrEq" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrLen = [Pair] -> Value
object ["LStrLen" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (LIntFloat ity :: IntTy
ity) = [Pair] -> Value
object ["LIntFloat" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LFloatInt ity :: IntTy
ity) = [Pair] -> Value
object ["LFloatInt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LIntStr ity :: IntTy
ity) = [Pair] -> Value
object ["LIntStr" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LStrInt ity :: IntTy
ity) = [Pair] -> Value
object ["LStrInt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LIntCh ity :: IntTy
ity) = [Pair] -> Value
object ["LIntCh" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON (LChInt ity :: IntTy
ity) = [Pair] -> Value
object ["LChInt" Text -> IntTy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= IntTy
ity]
    toJSON LFloatStr = [Pair] -> Value
object ["LFloatStr" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrFloat = [Pair] -> Value
object ["LStrFloat" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (LBitCast from :: ArithTy
from to :: ArithTy
to) = [Pair] -> Value
object ["LBitCast" Text -> (ArithTy, ArithTy) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (ArithTy
from, ArithTy
to)]
    toJSON LFExp = [Pair] -> Value
object ["LFExp" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFLog = [Pair] -> Value
object ["LFLog" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFSin = [Pair] -> Value
object ["LFSin" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFCos = [Pair] -> Value
object ["LFCos" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFTan = [Pair] -> Value
object ["LFTan" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFASin = [Pair] -> Value
object ["LFASin" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFACos = [Pair] -> Value
object ["LFACos" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFATan = [Pair] -> Value
object ["LFATan" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFATan2 = [Pair] -> Value
object ["LFATan2" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFSqrt = [Pair] -> Value
object ["LFSqrt" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFFloor = [Pair] -> Value
object ["LFFloor" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFCeil = [Pair] -> Value
object ["LFCeil" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFNegate = [Pair] -> Value
object ["LFNegate" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrHead = [Pair] -> Value
object ["LStrHead" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrTail = [Pair] -> Value
object ["LStrTail" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrCons = [Pair] -> Value
object ["LStrCons" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrIndex = [Pair] -> Value
object ["LStrIndex" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrRev = [Pair] -> Value
object ["LStrRev" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LStrSubstr = [Pair] -> Value
object ["LStrSubstr" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LReadStr = [Pair] -> Value
object ["LReadStr" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LWriteStr = [Pair] -> Value
object ["LWriteStr" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LSystemInfo = [Pair] -> Value
object ["LSystemInfo" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LFork = [Pair] -> Value
object ["LFork" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LPar = [Pair] -> Value
object ["LPar" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (LExternal name :: Name
name) = [Pair] -> Value
object ["LExternal" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
name]
    toJSON LCrash = [Pair] -> Value
object ["LCrash" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON LNoOp = [Pair] -> Value
object ["LNoOp" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]

instance ToJSON DDecl where
    toJSON :: DDecl -> Value
toJSON (DFun name :: Name
name args :: [Name]
args exp :: DExp
exp) = [Pair] -> Value
object ["DFun" Text -> (Name, [Name], DExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, [Name]
args, DExp
exp)]
    toJSON (DConstructor name :: Name
name tag :: Int
tag arity :: Int
arity) = [Pair] -> Value
object ["DConstructor" Text -> (Name, Int, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, Int
tag, Int
arity)]

instance ToJSON DExp where
    toJSON :: DExp -> Value
toJSON (DV lv :: Name
lv) = [Pair] -> Value
object ["DV" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
lv]
    toJSON (DApp tail :: Bool
tail name :: Name
name exps :: [DExp]
exps) = [Pair] -> Value
object ["DApp" Text -> (Bool, Name, [DExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
tail, Name
name, [DExp]
exps)]
    toJSON (DLet name :: Name
name a :: DExp
a b :: DExp
b) = [Pair] -> Value
object ["DLet" Text -> (Name, DExp, DExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, DExp
a, DExp
b)]
    toJSON (DUpdate name :: Name
name exp :: DExp
exp) = [Pair] -> Value
object ["DUpdate" Text -> (Name, DExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name,DExp
exp)]
    toJSON (DProj exp :: DExp
exp i :: Int
i) = [Pair] -> Value
object ["DProj" Text -> (DExp, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (DExp
exp, Int
i)]
    toJSON (DC lv :: Maybe Name
lv i :: Int
i name :: Name
name exp :: [DExp]
exp) = [Pair] -> Value
object ["DC" Text -> (Maybe Name, Int, Name, [DExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Maybe Name
lv, Int
i, Name
name, [DExp]
exp)]
    toJSON (DCase ct :: CaseType
ct exp :: DExp
exp alts :: [DAlt]
alts) = [Pair] -> Value
object ["DCase" Text -> (CaseType, DExp, [DAlt]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CaseType
ct, DExp
exp, [DAlt]
alts)]
    toJSON (DChkCase exp :: DExp
exp alts :: [DAlt]
alts) = [Pair] -> Value
object ["DChkCase" Text -> (DExp, [DAlt]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (DExp
exp, [DAlt]
alts)]
    toJSON (DConst c :: Const
c) = [Pair] -> Value
object ["DConst" Text -> Const -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Const
c]
    toJSON (DForeign fd :: FDesc
fd ret :: FDesc
ret exps :: [(FDesc, DExp)]
exps) = [Pair] -> Value
object ["DForeign" Text -> (FDesc, FDesc, [(FDesc, DExp)]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (FDesc
fd, FDesc
ret, [(FDesc, DExp)]
exps)]
    toJSON (DOp prim :: PrimFn
prim exps :: [DExp]
exps) = [Pair] -> Value
object ["DOp" Text -> (PrimFn, [DExp]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (PrimFn
prim, [DExp]
exps)]
    toJSON DNothing = [Pair] -> Value
object ["DNothing" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (DError s :: String
s) = [Pair] -> Value
object ["DError" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]

instance ToJSON DAlt where
    toJSON :: DAlt -> Value
toJSON (DConCase i :: Int
i n :: Name
n ns :: [Name]
ns exp :: DExp
exp) = [Pair] -> Value
object ["DConCase" Text -> (Int, Name, [Name], DExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
i, Name
n, [Name]
ns, DExp
exp)]
    toJSON (DConstCase c :: Const
c exp :: DExp
exp) = [Pair] -> Value
object ["DConstCase" Text -> (Const, DExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Const
c, DExp
exp)]
    toJSON (DDefaultCase exp :: DExp
exp) = [Pair] -> Value
object ["DDefaultCase" Text -> DExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= DExp
exp]

instance ToJSON SDecl where
    toJSON :: SDecl -> Value
toJSON (SFun name :: Name
name args :: [Name]
args i :: Int
i exp :: SExp
exp) = [Pair] -> Value
object ["SFun" Text -> (Name, [Name], Int, SExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
name, [Name]
args, Int
i, SExp
exp)]

instance ToJSON SExp where
    toJSON :: SExp -> Value
toJSON (SV lv :: LVar
lv) = [Pair] -> Value
object ["SV" Text -> LVar -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= LVar
lv]
    toJSON (SApp tail :: Bool
tail name :: Name
name exps :: [LVar]
exps) = [Pair] -> Value
object ["SApp" Text -> (Bool, Name, [LVar]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
tail, Name
name, [LVar]
exps)]
    toJSON (SLet lv :: LVar
lv a :: SExp
a b :: SExp
b) = [Pair] -> Value
object ["SLet" Text -> (LVar, SExp, SExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (LVar
lv, SExp
a, SExp
b)]
    toJSON (SUpdate lv :: LVar
lv exp :: SExp
exp) = [Pair] -> Value
object ["SUpdate" Text -> (LVar, SExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (LVar
lv, SExp
exp)]
    toJSON (SProj lv :: LVar
lv i :: Int
i) = [Pair] -> Value
object ["SProj" Text -> (LVar, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (LVar
lv, Int
i)]
    toJSON (SCon lv :: Maybe LVar
lv i :: Int
i name :: Name
name vars :: [LVar]
vars) = [Pair] -> Value
object ["SCon" Text -> (Maybe LVar, Int, Name, [LVar]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Maybe LVar
lv, Int
i, Name
name, [LVar]
vars)]
    toJSON (SCase ct :: CaseType
ct lv :: LVar
lv alts :: [SAlt]
alts) = [Pair] -> Value
object ["SCase" Text -> (CaseType, LVar, [SAlt]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CaseType
ct, LVar
lv, [SAlt]
alts)]
    toJSON (SChkCase lv :: LVar
lv alts :: [SAlt]
alts) = [Pair] -> Value
object ["SChkCase" Text -> (LVar, [SAlt]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (LVar
lv, [SAlt]
alts)]
    toJSON (SConst c :: Const
c) = [Pair] -> Value
object ["SConst" Text -> Const -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Const
c]
    toJSON (SForeign fd :: FDesc
fd ret :: FDesc
ret exps :: [(FDesc, LVar)]
exps) = [Pair] -> Value
object ["SForeign" Text -> (FDesc, FDesc, [(FDesc, LVar)]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (FDesc
fd, FDesc
ret, [(FDesc, LVar)]
exps)]
    toJSON (SOp prim :: PrimFn
prim vars :: [LVar]
vars) = [Pair] -> Value
object ["SOp" Text -> (PrimFn, [LVar]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (PrimFn
prim, [LVar]
vars)]
    toJSON SNothing = [Pair] -> Value
object ["SNothing" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (SError s :: String
s) = [Pair] -> Value
object ["SError" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]

instance ToJSON SAlt where
    toJSON :: SAlt -> Value
toJSON (SConCase i :: Int
i j :: Int
j n :: Name
n ns :: [Name]
ns exp :: SExp
exp) = [Pair] -> Value
object ["SConCase" Text -> (Int, Int, Name, [Name], SExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
i, Int
j, Name
n, [Name]
ns, SExp
exp)]
    toJSON (SConstCase c :: Const
c exp :: SExp
exp) = [Pair] -> Value
object ["SConstCase" Text -> (Const, SExp) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Const
c, SExp
exp)]
    toJSON (SDefaultCase exp :: SExp
exp) = [Pair] -> Value
object ["SDefaultCase" Text -> SExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= SExp
exp]

instance ToJSON BC where
    toJSON :: BC -> Value
toJSON (ASSIGN r1 :: Reg
r1 r2 :: Reg
r2) = [Pair] -> Value
object ["ASSIGN" Text -> (Reg, Reg) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r1, Reg
r2)]
    toJSON (ASSIGNCONST r :: Reg
r c :: Const
c) = [Pair] -> Value
object ["ASSIGNCONST" Text -> (Reg, Const) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r, Const
c)]
    toJSON (UPDATE r1 :: Reg
r1 r2 :: Reg
r2) = [Pair] -> Value
object ["UPDATE" Text -> (Reg, Reg) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r1, Reg
r2)]
    toJSON (MKCON con :: Reg
con mr :: Maybe Reg
mr i :: Int
i regs :: [Reg]
regs) = [Pair] -> Value
object ["MKCON" Text -> (Reg, Maybe Reg, Int, [Reg]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
con, Maybe Reg
mr, Int
i, [Reg]
regs)]
    toJSON (CASE b :: Bool
b r :: Reg
r alts :: [(Int, [BC])]
alts def :: Maybe [BC]
def) = [Pair] -> Value
object ["CASE" Text -> (Bool, Reg, [(Int, [BC])], Maybe [BC]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
b, Reg
r, [(Int, [BC])]
alts, Maybe [BC]
def)]
    toJSON (PROJECT r :: Reg
r loc :: Int
loc arity :: Int
arity) = [Pair] -> Value
object ["PROJECT" Text -> (Reg, Int, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r, Int
loc, Int
arity)]
    toJSON (PROJECTINTO r1 :: Reg
r1 r2 :: Reg
r2 loc :: Int
loc) = [Pair] -> Value
object ["PROJECTINTO" Text -> (Reg, Reg, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r1, Reg
r2, Int
loc)]
    toJSON (CONSTCASE r :: Reg
r alts :: [(Const, [BC])]
alts def :: Maybe [BC]
def) = [Pair] -> Value
object ["CONSTCASE" Text -> (Reg, [(Const, [BC])], Maybe [BC]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r, [(Const, [BC])]
alts, Maybe [BC]
def)]
    toJSON (CALL name :: Name
name) = [Pair] -> Value
object ["CALL" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
name]
    toJSON (TAILCALL name :: Name
name) = [Pair] -> Value
object ["TAILCALL" Text -> Name -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Name
name]
    toJSON (FOREIGNCALL r :: Reg
r fd :: FDesc
fd ret :: FDesc
ret exps :: [(FDesc, Reg)]
exps) = [Pair] -> Value
object ["FOREIGNCALL" Text -> (Reg, FDesc, FDesc, [(FDesc, Reg)]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r, FDesc
fd, FDesc
ret, [(FDesc, Reg)]
exps)]
    toJSON (SLIDE i :: Int
i) = [Pair] -> Value
object ["SLIDE" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (RESERVE i :: Int
i) = [Pair] -> Value
object ["RESERVE" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (RESERVENOALLOC i :: Int
i) = [Pair] -> Value
object ["RESERVENOALLOC" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (ADDTOP i :: Int
i) = [Pair] -> Value
object ["ADDTOP" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (TOPBASE i :: Int
i) = [Pair] -> Value
object ["TOPBASE" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (BASETOP i :: Int
i) = [Pair] -> Value
object ["BASETOP" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON REBASE = [Pair] -> Value
object ["REBASE" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON STOREOLD = [Pair] -> Value
object ["STOREOLD" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (OP r :: Reg
r prim :: PrimFn
prim args :: [Reg]
args) = [Pair] -> Value
object ["OP" Text -> (Reg, PrimFn, [Reg]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Reg
r, PrimFn
prim, [Reg]
args)]
    toJSON (NULL r :: Reg
r) = [Pair] -> Value
object ["NULL" Text -> Reg -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Reg
r]
    toJSON (ERROR s :: String
s) = [Pair] -> Value
object ["ERROR" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]

instance ToJSON Reg where
    toJSON :: Reg -> Value
toJSON RVal = [Pair] -> Value
object ["RVal" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (T i :: Int
i) = [Pair] -> Value
object ["T" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON (L i :: Int
i) = [Pair] -> Value
object ["L" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
i]
    toJSON Tmp = [Pair] -> Value
object ["Tmp" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]

instance ToJSON RigCount where
    toJSON :: RigCount -> Value
toJSON r :: RigCount
r = [Pair] -> Value
object ["RigCount" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= RigCount -> String
forall a. Show a => a -> String
show RigCount
r]

instance ToJSON Totality where
    toJSON :: Totality -> Value
toJSON t :: Totality
t = [Pair] -> Value
object ["Totality" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Totality -> String
forall a. Show a => a -> String
show Totality
t]

instance ToJSON MetaInformation where
    toJSON :: MetaInformation -> Value
toJSON m :: MetaInformation
m = [Pair] -> Value
object ["MetaInformation" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= MetaInformation -> String
forall a. Show a => a -> String
show MetaInformation
m]

instance ToJSON Def where
    toJSON :: Def -> Value
toJSON (Function ty :: Type
ty tm :: Type
tm) = [Pair] -> Value
object ["Function" Text -> (Type, Type) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Type
ty, Type
tm)]
    toJSON (TyDecl nm :: NameType
nm ty :: Type
ty) = [Pair] -> Value
object ["TyDecl" Text -> (NameType, Type) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (NameType
nm, Type
ty)]
    toJSON (Operator ty :: Type
ty n :: Int
n f :: [Value] -> Maybe Value
f) = Value
Null -- Operator and CaseOp omits same values as in IBC.hs
    toJSON (CaseOp info :: CaseInfo
info ty :: Type
ty argTy :: [(Type, Bool)]
argTy _ _ cdefs :: CaseDefs
cdefs) = [Pair] -> Value
object ["CaseOp" Text -> (CaseInfo, Type, [(Type, Bool)], CaseDefs) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CaseInfo
info, Type
ty, [(Type, Bool)]
argTy, CaseDefs
cdefs)]

instance (ToJSON t) => ToJSON (TT t) where
    toJSON :: TT t -> Value
toJSON (P nt :: NameType
nt name :: t
name term :: TT t
term) = [Pair] -> Value
object ["P" Text -> (NameType, t, TT t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (NameType
nt, t
name, TT t
term)]
    toJSON (V n :: Int
n) = [Pair] -> Value
object ["V" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
n]
    toJSON (Bind n :: t
n b :: Binder (TT t)
b tt :: TT t
tt) = [Pair] -> Value
object ["Bind" Text -> (t, Binder (TT t), TT t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
n, Binder (TT t)
b, TT t
tt)]
    toJSON (App s :: AppStatus t
s t1 :: TT t
t1 t2 :: TT t
t2) = [Pair] -> Value
object ["App" Text -> (AppStatus t, TT t, TT t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (AppStatus t
s, TT t
t1, TT t
t2)]
    toJSON (Constant c :: Const
c) = [Pair] -> Value
object ["Constant" Text -> Const -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Const
c]
    toJSON (Proj tt :: TT t
tt n :: Int
n) = [Pair] -> Value
object ["Proj" Text -> (TT t, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (TT t
tt, Int
n)]
    toJSON Erased = [Pair] -> Value
object ["Erased" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON Impossible = [Pair] -> Value
object ["Impossible" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (Inferred tt :: TT t
tt) = [Pair] -> Value
object ["Inferred" Text -> TT t -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= TT t
tt]
    toJSON (TType u :: UExp
u) = [Pair] -> Value
object ["TType" Text -> UExp -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= UExp
u]
    toJSON (UType u :: Universe
u) = [Pair] -> Value
object ["UType" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Universe -> String
forall a. Show a => a -> String
show Universe
u)]

instance ToJSON UExp where
    toJSON :: UExp -> Value
toJSON (UVar src :: String
src n :: Int
n) = [Pair] -> Value
object ["UVar" Text -> (String, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (String
src, Int
n)]
    toJSON (UVal n :: Int
n) = [Pair] -> Value
object ["UVal" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Int
n]


instance (ToJSON t) => ToJSON (AppStatus t) where
    toJSON :: AppStatus t -> Value
toJSON Complete = [Pair] -> Value
object ["Complete" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON MaybeHoles = [Pair] -> Value
object ["MaybeHoles" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (Holes ns :: [t]
ns) = [Pair] -> Value
object ["Holes" Text -> [t] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [t]
ns]

instance (ToJSON t) => ToJSON (Binder t) where
    toJSON :: Binder t -> Value
toJSON (Lam rc :: RigCount
rc bty :: t
bty) = [Pair] -> Value
object ["Lam" Text -> (RigCount, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (RigCount
rc, t
bty)]
    toJSON (Pi c :: RigCount
c i :: Maybe ImplicitInfo
i t :: t
t k :: t
k) = [Pair] -> Value
object ["Pi" Text -> (RigCount, Maybe ImplicitInfo, t, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (RigCount
c, Maybe ImplicitInfo
i, t
t, t
k)]
    toJSON (Let rc :: RigCount
rc t :: t
t v :: t
v) = [Pair] -> Value
object ["Let" Text -> (t, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t, t
v)]
    toJSON (NLet t :: t
t v :: t
v) = [Pair] -> Value
object ["NLet" Text -> (t, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t, t
v)]
    toJSON (Hole t :: t
t) = [Pair] -> Value
object ["Hole" Text -> t -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t)]
    toJSON (GHole l :: Int
l ns :: [Name]
ns t :: t
t) = [Pair] -> Value
object ["GHole" Text -> (Int, [Name], t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
l, [Name]
ns, t
t)]
    toJSON (Guess t :: t
t v :: t
v) = [Pair] -> Value
object ["Guess" Text -> (t, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t, t
v)]
    toJSON (PVar rc :: RigCount
rc t :: t
t) = [Pair] -> Value
object ["PVar" Text -> (RigCount, t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (RigCount
rc, t
t)]
    toJSON (PVTy t :: t
t) = [Pair] -> Value
object ["PVTy" Text -> t -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t)]

instance ToJSON ImplicitInfo where
    toJSON :: ImplicitInfo -> Value
toJSON (Impl a :: Bool
a b :: Bool
b c :: Bool
c) = [Pair] -> Value
object ["Impl" Text -> (Bool, Bool, Bool) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
a, Bool
b, Bool
c)]

instance ToJSON NameType where
    toJSON :: NameType -> Value
toJSON Bound = [Pair] -> Value
object ["Bound" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON Ref = [Pair] -> Value
object ["Ref" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]
    toJSON (DCon a :: Int
a b :: Int
b c :: Bool
c) = [Pair] -> Value
object ["DCon" Text -> (Int, Int, Bool) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
a, Int
b, Bool
c)]
    toJSON (TCon a :: Int
a b :: Int
b) = [Pair] -> Value
object ["TCon" Text -> (Int, Int) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Int
a, Int
b)]

instance ToJSON CaseDefs where
    toJSON :: CaseDefs -> Value
toJSON (CaseDefs rt :: ([Name], SC)
rt ct :: ([Name], SC)
ct) = [Pair] -> Value
object ["Runtime" Text -> ([Name], SC) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ([Name], SC)
rt, "Compiletime" Text -> ([Name], SC) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= ([Name], SC)
ct]

instance (ToJSON t) => ToJSON (SC' t) where
    toJSON :: SC' t -> Value
toJSON (Case ct :: CaseType
ct n :: Name
n alts :: [CaseAlt' t]
alts) = [Pair] -> Value
object ["Case" Text -> (CaseType, Name, [CaseAlt' t]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (CaseType
ct, Name
n, [CaseAlt' t]
alts)]
    toJSON (ProjCase t :: t
t alts :: [CaseAlt' t]
alts) = [Pair] -> Value
object ["ProjCase" Text -> (t, [CaseAlt' t]) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (t
t, [CaseAlt' t]
alts)]
    toJSON (STerm t :: t
t) = [Pair] -> Value
object ["STerm" Text -> t -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= t
t]
    toJSON (UnmatchedCase s :: String
s) = [Pair] -> Value
object ["UnmatchedCase" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= String
s]
    toJSON ImpossibleCase = [Pair] -> Value
object ["ImpossibleCase" Text -> Value -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Value
Null]

instance (ToJSON t) => ToJSON (CaseAlt' t) where
    toJSON :: CaseAlt' t -> Value
toJSON (ConCase n :: Name
n c :: Int
c ns :: [Name]
ns sc :: SC' t
sc) = [Pair] -> Value
object ["ConCase" Text -> (Name, Int, [Name], SC' t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
n, Int
c, [Name]
ns, SC' t
sc)]
    toJSON (FnCase n :: Name
n ns :: [Name]
ns sc :: SC' t
sc) = [Pair] -> Value
object ["FnCase" Text -> (Name, [Name], SC' t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
n, [Name]
ns, SC' t
sc)]
    toJSON (ConstCase c :: Const
c sc :: SC' t
sc) = [Pair] -> Value
object ["ConstCase" Text -> (Const, SC' t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Const
c, SC' t
sc)]
    toJSON (SucCase n :: Name
n sc :: SC' t
sc) = [Pair] -> Value
object ["SucCase" Text -> (Name, SC' t) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Name
n, SC' t
sc)]
    toJSON (DefaultCase sc :: SC' t
sc) = [Pair] -> Value
object ["DefaultCase" Text -> SC' t -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.=  SC' t
sc]

instance ToJSON CaseInfo where
    toJSON :: CaseInfo -> Value
toJSON (CaseInfo a :: Bool
a b :: Bool
b c :: Bool
c) = [Pair] -> Value
object ["CaseInfo" Text -> (Bool, Bool, Bool) -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= (Bool
a, Bool
b, Bool
c)]

instance ToJSON Accessibility where
    toJSON :: Accessibility -> Value
toJSON a :: Accessibility
a = [Pair] -> Value
object ["Accessibility" Text -> String -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Accessibility -> String
forall a. Show a => a -> String
show Accessibility
a]