{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeSynonymInstances #-}

module Cubix.ParsePretty(
    ParseFile(..)
  , Pretty(..)

  , parseLua
  , prettyLua

#ifndef ONLY_ONE_LANGUAGE
  , parseC
  , parseJava
  , parseJavaScript
  , parsePython

  , prettyC
  , prettyJava
  , prettyJavaScript
  , prettyPython
#endif
  ) where


import Control.Monad ( liftM, (>=>) )
import Control.Monad.Identity ( runIdentity )

import Data.Comp.Multi ( Term, stripA, ann )
import Data.Comp.Multi.Strategic ( RewriteM, allbuR, promoteR )
import Data.Comp.Multi.Strategy.Classification ( DynCase, fromDynProj )


import qualified Language.C as C
import qualified Language.Java.Pretty as Java
import qualified Language.JavaScript.Parser as JS
import qualified Language.JavaScript.Pretty.Printer.Extended as JS
import qualified Language.Lua.Annotated as Lua
import qualified Language.Lua.Annotated.Lexer as Lua
import qualified Language.Lua.PrettyPrinter as Lua
import qualified Language.Lua.Annotated.Simplify as Lua
import qualified Language.Python.Common as Python
import qualified Language.Python.Version3.Parser as Python

import Cubix.Language.Info

import Cubix.Language.C.Parametric.Common as CCommon
import qualified Cubix.Language.C.Parametric.Full as CFull
import qualified Cubix.Language.C.Parse as CParse
import qualified Cubix.Language.Java.Parse as JParse
import Cubix.Language.Java.Parametric.Common as JCommon
import qualified Cubix.Language.Java.Parametric.Full as JFull
import Cubix.Language.JavaScript.Parametric.Common as JSCommon
import qualified Cubix.Language.JavaScript.Parametric.Full as JSFull
import Cubix.Language.Lua.Parametric.Common as LCommon
import qualified Cubix.Language.Lua.Parametric.Full as LFull
import Cubix.Language.Python.Parametric.Common as PCommon
import qualified Cubix.Language.Python.Parametric.Full as PFull
import qualified Data.Text as T (unpack)


type family RootSort (fs :: [(* -> *) -> * -> *])

class ParseFile fs where
  -- | Parses a file with the appropriate parser for the language with signature @fs@.
  --
  -- Recommended to use with the @TypeApplications@ extension,
  -- e.g.: @parseFile \@MCSig "my_file.c"@.
  parseFile :: FilePath -> IO (Maybe (Term fs (RootSort fs)))

class Pretty fs where
  -- | Pretty-prints a term, using the appropriate pretty-printer for the language with
  -- signature @fs@.
  pretty :: Term fs (RootSort fs) -> String

  -- FIXME: The only reason this is needed is because Project forgets
  -- what sort its contents are
  prettyUnsafe :: Term fs l -> String
  default prettyUnsafe :: (DynCase (Term fs) (RootSort fs)) => Term fs l -> String
  prettyUnsafe = Cxt NoHole (Sum fs) (K ()) (RootSort fs) -> String
forall (fs :: [(* -> *) -> * -> *]).
Pretty fs =>
Cxt NoHole (Sum fs) (K ()) (RootSort fs) -> String
pretty (Cxt NoHole (Sum fs) (K ()) (RootSort fs) -> String)
-> (Term fs l -> Cxt NoHole (Sum fs) (K ()) (RootSort fs))
-> Term fs l
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Term fs l -> Cxt NoHole (Sum fs) (K ()) (RootSort fs)
forall (f :: * -> *) l l'. DynCase f l => f l' -> f l
fromDynProj

-- | NOTE: This reflects the half-finished transition of Lua to annotated terms
parseLua :: FilePath -> IO (Maybe (MLuaTerm LBlockL))
parseLua :: String -> IO (Maybe (MLuaTerm LBlockL))
parseLua path :: String
path = do
    Either (SourceRange, String) (Block SourceRange)
res <- String -> IO (Either (SourceRange, String) (Block SourceRange))
Lua.parseFile String
path
    case Either (SourceRange, String) (Block SourceRange)
res of
     Left errors :: (SourceRange, String)
errors -> (SourceRange, String) -> IO ()
forall a. Show a => a -> IO ()
print (SourceRange, String)
errors IO ()
-> IO (Maybe (MLuaTerm LBlockL)) -> IO (Maybe (MLuaTerm LBlockL))
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe (MLuaTerm LBlockL) -> IO (Maybe (MLuaTerm LBlockL))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (MLuaTerm LBlockL)
forall a. Maybe a
Nothing
     Right tree :: Block SourceRange
tree  -> Maybe (MLuaTerm LBlockL) -> IO (Maybe (MLuaTerm LBlockL))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MLuaTerm LBlockL) -> IO (Maybe (MLuaTerm LBlockL)))
-> Maybe (MLuaTerm LBlockL) -> IO (Maybe (MLuaTerm LBlockL))
forall a b. (a -> b) -> a -> b
$ MLuaTerm LBlockL -> Maybe (MLuaTerm LBlockL)
forall a. a -> Maybe a
Just (MLuaTerm LBlockL -> Maybe (MLuaTerm LBlockL))
-> MLuaTerm LBlockL -> Maybe (MLuaTerm LBlockL)
forall a b. (a -> b) -> a -> b
$ LuaTerm LBlockL -> MLuaTerm LBlockL
forall l. LuaTerm l -> MLuaTerm l
LCommon.translate (LuaTerm LBlockL -> MLuaTerm LBlockL)
-> LuaTerm LBlockL -> MLuaTerm LBlockL
forall a b. (a -> b) -> a -> b
$ {-stripA $-} Block (Maybe SourceSpan) -> LuaTerm LBlockL
LFull.translate (Block (Maybe SourceSpan) -> LuaTerm LBlockL)
-> Block (Maybe SourceSpan) -> LuaTerm LBlockL
forall a b. (a -> b) -> a -> b
$ (SourceRange -> Maybe SourceSpan)
-> Block SourceRange -> Block (Maybe SourceSpan)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SourceRange -> Maybe SourceSpan
toSourceSpan Block SourceRange
tree
  where
    toSourceSpan :: Lua.SourceRange -> Maybe SourceSpan
    toSourceSpan :: SourceRange -> Maybe SourceSpan
toSourceSpan x :: SourceRange
x = SourceSpan -> Maybe SourceSpan
forall a. a -> Maybe a
Just (SourceSpan -> Maybe SourceSpan) -> SourceSpan -> Maybe SourceSpan
forall a b. (a -> b) -> a -> b
$ String -> (Int, Int) -> (Int, Int) -> SourceSpan
mkSourceSpan (Text -> String
T.unpack (SourcePos -> Text
Lua.sourceFile SourcePos
from))
                                         (SourcePos -> Int
Lua.sourceLine SourcePos
from, SourcePos -> Int
Lua.sourceColumn SourcePos
from)
                                         (SourcePos -> Int
Lua.sourceLine SourcePos
to,   SourcePos -> Int
Lua.sourceColumn SourcePos
to)
      where
        from :: SourcePos
from = SourceRange -> SourcePos
Lua.sourceFrom SourceRange
x
        to :: SourcePos
to   = SourceRange -> SourcePos
Lua.sourceTo   SourceRange
x

prettyLua :: MLuaTerm LBlockL -> String
prettyLua :: MLuaTerm LBlockL -> String
prettyLua = Doc -> String
forall a. Show a => a -> String
show (Doc -> String)
-> (MLuaTerm LBlockL -> Doc) -> MLuaTerm LBlockL -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Block -> Doc
forall a. LPretty a => a -> Doc
Lua.pprint (Block -> Doc)
-> (MLuaTerm LBlockL -> Block) -> MLuaTerm LBlockL -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Block (Maybe SourceSpan) -> Block
forall a. Block a -> Block
Lua.sBlock (Block (Maybe SourceSpan) -> Block)
-> (MLuaTerm LBlockL -> Block (Maybe SourceSpan))
-> MLuaTerm LBlockL
-> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnnTerm (Maybe SourceSpan) LuaSig LBlockL
-> Block (Maybe SourceSpan)
forall i. AnnTerm (Maybe SourceSpan) LuaSig i -> Targ i
LFull.untranslate (AnnTerm (Maybe SourceSpan) LuaSig LBlockL
 -> Block (Maybe SourceSpan))
-> (MLuaTerm LBlockL -> AnnTerm (Maybe SourceSpan) LuaSig LBlockL)
-> MLuaTerm LBlockL
-> Block (Maybe SourceSpan)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe SourceSpan
-> CxtFun (Sum LuaSig) (Sum LuaSig :&: Maybe SourceSpan)
forall (f :: (* -> *) -> * -> *) p.
HFunctor f =>
p -> CxtFun f (f :&: p)
ann Maybe SourceSpan
forall a. Maybe a
Nothing (LuaTerm LBlockL -> AnnTerm (Maybe SourceSpan) LuaSig LBlockL)
-> (MLuaTerm LBlockL -> LuaTerm LBlockL)
-> MLuaTerm LBlockL
-> AnnTerm (Maybe SourceSpan) LuaSig LBlockL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MLuaTerm LBlockL -> LuaTerm LBlockL
forall l. MLuaTerm l -> LuaTerm l
LCommon.untranslate

type instance RootSort MLuaSig = LBlockL
instance ParseFile MLuaSig where parseFile :: String -> IO (Maybe (Term MLuaSig (RootSort MLuaSig)))
parseFile = String -> IO (Maybe (MLuaTerm LBlockL))
String -> IO (Maybe (Term MLuaSig (RootSort MLuaSig)))
parseLua
instance Pretty MLuaSig where pretty :: Term MLuaSig (RootSort MLuaSig) -> String
pretty = MLuaTerm LBlockL -> String
Term MLuaSig (RootSort MLuaSig) -> String
prettyLua

#ifndef ONLY_ONE_LANGUAGE

parseC :: FilePath -> IO (Maybe (MCTerm CTranslationUnitL))
parseC :: String -> IO (Maybe (MCTerm CTranslationUnitL))
parseC path :: String
path = do
  Either String CTranslUnit
res <- String -> IO (Either String CTranslUnit)
CParse.parse String
path
  case Either String CTranslUnit
res of
    Left errors :: String
errors -> String -> IO ()
forall a. Show a => a -> IO ()
print String
errors IO ()
-> IO (Maybe (MCTerm CTranslationUnitL))
-> IO (Maybe (MCTerm CTranslationUnitL))
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe (MCTerm CTranslationUnitL)
-> IO (Maybe (MCTerm CTranslationUnitL))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (MCTerm CTranslationUnitL)
forall a. Maybe a
Nothing
    Right tree :: CTranslUnit
tree -> Maybe (MCTerm CTranslationUnitL)
-> IO (Maybe (MCTerm CTranslationUnitL))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MCTerm CTranslationUnitL)
 -> IO (Maybe (MCTerm CTranslationUnitL)))
-> Maybe (MCTerm CTranslationUnitL)
-> IO (Maybe (MCTerm CTranslationUnitL))
forall a b. (a -> b) -> a -> b
$ MCTerm CTranslationUnitL -> Maybe (MCTerm CTranslationUnitL)
forall a. a -> Maybe a
Just (MCTerm CTranslationUnitL -> Maybe (MCTerm CTranslationUnitL))
-> MCTerm CTranslationUnitL -> Maybe (MCTerm CTranslationUnitL)
forall a b. (a -> b) -> a -> b
$ CTerm CTranslationUnitL -> MCTerm CTranslationUnitL
forall l. CTerm l -> MCTerm l
CCommon.translate (CTerm CTranslationUnitL -> MCTerm CTranslationUnitL)
-> CTerm CTranslationUnitL -> MCTerm CTranslationUnitL
forall a b. (a -> b) -> a -> b
$ CTranslationUnit () -> CTerm CTranslationUnitL
CFull.translate (CTranslationUnit () -> CTerm CTranslationUnitL)
-> CTranslationUnit () -> CTerm CTranslationUnitL
forall a b. (a -> b) -> a -> b
$ (NodeInfo -> ()) -> CTranslUnit -> CTranslationUnit ()
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> NodeInfo -> ()
forall a b. a -> b -> a
const ()) CTranslUnit
tree


dummyNodeInfo :: C.NodeInfo
dummyNodeInfo :: NodeInfo
dummyNodeInfo = Position -> NodeInfo
C.mkNodeInfoOnlyPos Position
C.nopos


prettyC :: MCTerm CTranslationUnitL -> String
prettyC :: MCTerm CTranslationUnitL -> String
prettyC = Doc -> String
forall a. Show a => a -> String
show (Doc -> String)
-> (MCTerm CTranslationUnitL -> Doc)
-> MCTerm CTranslationUnitL
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CTranslUnit -> Doc
forall p. Pretty p => p -> Doc
C.pretty (CTranslUnit -> Doc)
-> (MCTerm CTranslationUnitL -> CTranslUnit)
-> MCTerm CTranslationUnitL
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (() -> NodeInfo) -> CTranslationUnit () -> CTranslUnit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NodeInfo -> () -> NodeInfo
forall a b. a -> b -> a
const NodeInfo
dummyNodeInfo) (CTranslationUnit () -> CTranslUnit)
-> (MCTerm CTranslationUnitL -> CTranslationUnit ())
-> MCTerm CTranslationUnitL
-> CTranslUnit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CTerm CTranslationUnitL -> CTranslationUnit ()
forall i. CTerm i -> Targ i
CFull.untranslate (CTerm CTranslationUnitL -> CTranslationUnit ())
-> (MCTerm CTranslationUnitL -> CTerm CTranslationUnitL)
-> MCTerm CTranslationUnitL
-> CTranslationUnit ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MCTerm CTranslationUnitL -> CTerm CTranslationUnitL
forall l. MCTerm l -> CTerm l
CCommon.untranslate

type instance RootSort MCSig = CTranslationUnitL
instance ParseFile MCSig where parseFile :: String -> IO (Maybe (Term MCSig (RootSort MCSig)))
parseFile = String -> IO (Maybe (MCTerm CTranslationUnitL))
String -> IO (Maybe (Term MCSig (RootSort MCSig)))
parseC
instance Pretty MCSig where pretty :: Term MCSig (RootSort MCSig) -> String
pretty = MCTerm CTranslationUnitL -> String
Term MCSig (RootSort MCSig) -> String
prettyC

parseJava :: FilePath -> IO (Maybe (MJavaTerm CompilationUnitL))
parseJava :: String -> IO (Maybe (MJavaTerm CompilationUnitL))
parseJava path :: String
path = do
  Either String CompilationUnit
res <- String -> IO (Either String CompilationUnit)
JParse.parse String
path
  case Either String CompilationUnit
res of
    Left  x :: String
x -> Maybe (MJavaTerm CompilationUnitL)
-> IO (Maybe (MJavaTerm CompilationUnitL))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (MJavaTerm CompilationUnitL)
forall a. Maybe a
Nothing
    Right p :: CompilationUnit
p -> Maybe (MJavaTerm CompilationUnitL)
-> IO (Maybe (MJavaTerm CompilationUnitL))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MJavaTerm CompilationUnitL)
 -> IO (Maybe (MJavaTerm CompilationUnitL)))
-> Maybe (MJavaTerm CompilationUnitL)
-> IO (Maybe (MJavaTerm CompilationUnitL))
forall a b. (a -> b) -> a -> b
$ MJavaTerm CompilationUnitL -> Maybe (MJavaTerm CompilationUnitL)
forall a. a -> Maybe a
Just (MJavaTerm CompilationUnitL -> Maybe (MJavaTerm CompilationUnitL))
-> MJavaTerm CompilationUnitL -> Maybe (MJavaTerm CompilationUnitL)
forall a b. (a -> b) -> a -> b
$ JavaTerm CompilationUnitL -> MJavaTerm CompilationUnitL
forall l. JavaTerm l -> MJavaTerm l
JCommon.translate (JavaTerm CompilationUnitL -> MJavaTerm CompilationUnitL)
-> JavaTerm CompilationUnitL -> MJavaTerm CompilationUnitL
forall a b. (a -> b) -> a -> b
$ CompilationUnit -> JavaTerm CompilationUnitL
JFull.translate CompilationUnit
p


prettyJava :: MJavaTerm CompilationUnitL -> String
prettyJava :: MJavaTerm CompilationUnitL -> String
prettyJava = CompilationUnit -> String
forall a. Pretty a => a -> String
Java.prettyPrint (CompilationUnit -> String)
-> (MJavaTerm CompilationUnitL -> CompilationUnit)
-> MJavaTerm CompilationUnitL
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JavaTerm CompilationUnitL -> CompilationUnit
forall i. JavaTerm i -> Targ i
JFull.untranslate (JavaTerm CompilationUnitL -> CompilationUnit)
-> (MJavaTerm CompilationUnitL -> JavaTerm CompilationUnitL)
-> MJavaTerm CompilationUnitL
-> CompilationUnit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MJavaTerm CompilationUnitL -> JavaTerm CompilationUnitL
forall l. MJavaTerm l -> JavaTerm l
JCommon.untranslate


type instance RootSort MJavaSig = CompilationUnitL
instance ParseFile MJavaSig where parseFile :: String -> IO (Maybe (Term MJavaSig (RootSort MJavaSig)))
parseFile = String -> IO (Maybe (MJavaTerm CompilationUnitL))
String -> IO (Maybe (Term MJavaSig (RootSort MJavaSig)))
parseJava
instance Pretty MJavaSig where pretty :: Term MJavaSig (RootSort MJavaSig) -> String
pretty = MJavaTerm CompilationUnitL -> String
Term MJavaSig (RootSort MJavaSig) -> String
prettyJava

parseJavaScript :: FilePath -> IO (Maybe (MJSTerm JSASTL))
parseJavaScript :: String -> IO (Maybe (MJSTerm JSASTL))
parseJavaScript path :: String
path = (JSAST -> Maybe (MJSTerm JSASTL))
-> IO JSAST -> IO (Maybe (MJSTerm JSASTL))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (MJSTerm JSASTL -> Maybe (MJSTerm JSASTL)
forall a. a -> Maybe a
Just (MJSTerm JSASTL -> Maybe (MJSTerm JSASTL))
-> (JSAST -> MJSTerm JSASTL) -> JSAST -> Maybe (MJSTerm JSASTL)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm JSASTL -> MJSTerm JSASTL
forall l. JSTerm l -> MJSTerm l
JSCommon.translate (JSTerm JSASTL -> MJSTerm JSASTL)
-> (JSAST -> JSTerm JSASTL) -> JSAST -> MJSTerm JSASTL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm JSASTL -> JSTerm JSASTL
normalizeJS (JSTerm JSASTL -> JSTerm JSASTL)
-> (JSAST -> JSTerm JSASTL) -> JSAST -> JSTerm JSASTL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSAST -> JSTerm JSASTL
JSFull.translate) (IO JSAST -> IO (Maybe (MJSTerm JSASTL)))
-> IO JSAST -> IO (Maybe (MJSTerm JSASTL))
forall a b. (a -> b) -> a -> b
$ String -> IO JSAST
JS.parseFile String
path
  where
    normalizeJS :: JSFull.JSTerm JSASTL -> JSFull.JSTerm JSASTL
    normalizeJS :: JSTerm JSASTL -> JSTerm JSASTL
normalizeJS t :: JSTerm JSASTL
t = Identity (JSTerm JSASTL) -> JSTerm JSASTL
forall a. Identity a -> a
runIdentity (Identity (JSTerm JSASTL) -> JSTerm JSASTL)
-> Identity (JSTerm JSASTL) -> JSTerm JSASTL
forall a b. (a -> b) -> a -> b
$ GRewriteM Identity (Cxt NoHole (Sum JSSig) (K ()))
-> RewriteM Identity (Cxt NoHole (Sum JSSig) (K ())) JSASTL
forall (m :: * -> *) (f :: (* -> *) -> * -> *) h (a :: * -> *).
(Monad m, HTraversable f) =>
GRewriteM m (Cxt h f a) -> GRewriteM m (Cxt h f a)
allbuR (RewriteM (MaybeT Identity) (Cxt NoHole (Sum JSSig) (K ())) JSSemiL
-> GRewriteM Identity (Cxt NoHole (Sum JSSig) (K ()))
forall (f :: * -> *) l (m :: * -> *).
(DynCase f l, Monad m) =>
RewriteM (MaybeT m) f l -> GRewriteM m f
promoteR RewriteM (MaybeT Identity) (Cxt NoHole (Sum JSSig) (K ())) JSSemiL
forall (m :: * -> *).
Monad m =>
RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSSemiL
normalizeSemi (Cxt NoHole (Sum JSSig) (K ()) l
 -> Identity (Cxt NoHole (Sum JSSig) (K ()) l))
-> (Cxt NoHole (Sum JSSig) (K ()) l
    -> Identity (Cxt NoHole (Sum JSSig) (K ()) l))
-> Cxt NoHole (Sum JSSig) (K ()) l
-> Identity (Cxt NoHole (Sum JSSig) (K ()) l)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> RewriteM (MaybeT Identity) (Cxt NoHole (Sum JSSig) (K ())) JSAnnotL
-> GRewriteM Identity (Cxt NoHole (Sum JSSig) (K ()))
forall (f :: * -> *) l (m :: * -> *).
(DynCase f l, Monad m) =>
RewriteM (MaybeT m) f l -> GRewriteM m f
promoteR RewriteM (MaybeT Identity) (Cxt NoHole (Sum JSSig) (K ())) JSAnnotL
forall (m :: * -> *).
Monad m =>
RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSAnnotL
normalizeAnno) JSTerm JSASTL
t

    normalizeSemi :: (Monad m) => RewriteM m JSFull.JSTerm JSSemiL
    normalizeSemi :: RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSSemiL
normalizeSemi _ = RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSSemiL
forall (m :: * -> *) a. Monad m => a -> m a
return (CxtS NoHole JSSig (K ()) JSAnnotL
-> CxtS NoHole JSSig (K ()) JSSemiL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSSemi :-<: fs, InjF fs JSSemiL j) =>
CxtS h fs a JSAnnotL -> CxtS h fs a j
iJSSemi CxtS NoHole JSSig (K ()) JSAnnotL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAnnot :-<: fs, InjF fs JSAnnotL j) =>
CxtS h fs a j
iJSNoAnnot)

    normalizeAnno :: (Monad m) => RewriteM m JSFull.JSTerm JSAnnotL
    normalizeAnno :: RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSAnnotL
normalizeAnno _ = RewriteM m (Cxt NoHole (Sum JSSig) (K ())) JSAnnotL
forall (m :: * -> *) a. Monad m => a -> m a
return CxtS NoHole JSSig (K ()) JSAnnotL
forall h (fs :: [(* -> *) -> * -> *]) (a :: * -> *) j.
(JSAnnot :-<: fs, InjF fs JSAnnotL j) =>
CxtS h fs a j
iJSNoAnnot

prettyJavaScript :: MJSTerm JSASTL -> String
prettyJavaScript :: MJSTerm JSASTL -> String
prettyJavaScript =  JSAST -> String
forall a. Pretty a => a -> String
JS.prettyPrint (JSAST -> String)
-> (MJSTerm JSASTL -> JSAST) -> MJSTerm JSASTL -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JSTerm JSASTL -> JSAST
forall i. JSTerm i -> Targ i
JSFull.untranslate (JSTerm JSASTL -> JSAST)
-> (MJSTerm JSASTL -> JSTerm JSASTL) -> MJSTerm JSASTL -> JSAST
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MJSTerm JSASTL -> JSTerm JSASTL
forall l. MJSTerm l -> JSTerm l
JSCommon.untranslate


type instance RootSort MJSSig = JSASTL
instance ParseFile MJSSig where parseFile :: String -> IO (Maybe (Term MJSSig (RootSort MJSSig)))
parseFile = String -> IO (Maybe (MJSTerm JSASTL))
String -> IO (Maybe (Term MJSSig (RootSort MJSSig)))
parseJavaScript
instance Pretty MJSSig where pretty :: Term MJSSig (RootSort MJSSig) -> String
pretty = MJSTerm JSASTL -> String
Term MJSSig (RootSort MJSSig) -> String
prettyJavaScript

parsePython :: FilePath -> IO (Maybe (MPythonTerm PCommon.ModuleL))
parsePython :: String -> IO (Maybe (MPythonTerm ModuleL))
parsePython path :: String
path = do
  String
contents <- String -> IO String
readFile String
path
  let res :: Either ParseError (ModuleSpan, [Token])
res = String -> String -> Either ParseError (ModuleSpan, [Token])
Python.parseModule String
contents String
path
  case Either ParseError (ModuleSpan, [Token])
res of
    Left  e :: ParseError
e     -> ParseError -> IO ()
forall a. Show a => a -> IO ()
print ParseError
e IO ()
-> IO (Maybe (MPythonTerm ModuleL))
-> IO (Maybe (MPythonTerm ModuleL))
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe (MPythonTerm ModuleL) -> IO (Maybe (MPythonTerm ModuleL))
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (MPythonTerm ModuleL)
forall a. Maybe a
Nothing
    Right (m :: ModuleSpan
m, _) -> Maybe (MPythonTerm ModuleL) -> IO (Maybe (MPythonTerm ModuleL))
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (MPythonTerm ModuleL) -> IO (Maybe (MPythonTerm ModuleL)))
-> Maybe (MPythonTerm ModuleL) -> IO (Maybe (MPythonTerm ModuleL))
forall a b. (a -> b) -> a -> b
$ MPythonTerm ModuleL -> Maybe (MPythonTerm ModuleL)
forall a. a -> Maybe a
Just (MPythonTerm ModuleL -> Maybe (MPythonTerm ModuleL))
-> MPythonTerm ModuleL -> Maybe (MPythonTerm ModuleL)
forall a b. (a -> b) -> a -> b
$ PythonTerm ModuleL -> MPythonTerm ModuleL
forall l. PythonTerm l -> MPythonTerm l
PCommon.translate (PythonTerm ModuleL -> MPythonTerm ModuleL)
-> PythonTerm ModuleL -> MPythonTerm ModuleL
forall a b. (a -> b) -> a -> b
$ Module () -> PythonTerm ModuleL
PFull.translate (Module () -> PythonTerm ModuleL)
-> Module () -> PythonTerm ModuleL
forall a b. (a -> b) -> a -> b
$ (SrcSpan -> ()) -> ModuleSpan -> Module ()
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (() -> SrcSpan -> ()
forall a b. a -> b -> a
const ()) ModuleSpan
m

prettyPython :: MPythonTerm PCommon.ModuleL -> String
prettyPython :: MPythonTerm ModuleL -> String
prettyPython = Doc -> String
forall a. Show a => a -> String
show (Doc -> String)
-> (MPythonTerm ModuleL -> Doc) -> MPythonTerm ModuleL -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Module () -> Doc
forall a. Pretty a => a -> Doc
Python.pretty (Module () -> Doc)
-> (MPythonTerm ModuleL -> Module ()) -> MPythonTerm ModuleL -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PythonTerm ModuleL -> Module ()
forall i. PythonTerm i -> Targ i
PFull.untranslate (PythonTerm ModuleL -> Module ())
-> (MPythonTerm ModuleL -> PythonTerm ModuleL)
-> MPythonTerm ModuleL
-> Module ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MPythonTerm ModuleL -> PythonTerm ModuleL
forall l. MPythonTerm l -> PythonTerm l
PCommon.untranslate


type instance RootSort MPythonSig = PCommon.ModuleL
instance ParseFile MPythonSig where parseFile :: String -> IO (Maybe (Term MPythonSig (RootSort MPythonSig)))
parseFile = String -> IO (Maybe (MPythonTerm ModuleL))
String -> IO (Maybe (Term MPythonSig (RootSort MPythonSig)))
parsePython
instance Pretty MPythonSig where pretty :: Term MPythonSig (RootSort MPythonSig) -> String
pretty = MPythonTerm ModuleL -> String
Term MPythonSig (RootSort MPythonSig) -> String
prettyPython

#endif