diff --git a/AUTHORS b/AUTHORS --- a/AUTHORS +++ b/AUTHORS @@ -19,3 +19,4 @@ Pasqualino Titto Assini Rob Zinkov Samuel Gélineau +Sid Kapur diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,8 @@ +### 0.6.0 + +* Support for GHC 8.0 +* Add `displayException` to InterpreterError + ### 0.5.2 * Add `runInterpreter` variant that takes a GHC libdir at runtime diff --git a/hint.cabal b/hint.cabal --- a/hint.cabal +++ b/hint.cabal @@ -1,5 +1,5 @@ name: hint -version: 0.5.2 +version: 0.6.0 description: This library defines an Interpreter monad. It allows to load Haskell modules, browse them, type-check and evaluate strings with Haskell @@ -45,7 +45,7 @@ Library build-depends: base == 4.*, - ghc >= 7.6 && < 8, + ghc >= 7.6 && < 8.2, ghc-paths, mtl, filepath, diff --git a/src/Control/Monad/Ghc.hs b/src/Control/Monad/Ghc.hs --- a/src/Control/Monad/Ghc.hs +++ b/src/Control/Monad/Ghc.hs @@ -25,7 +25,11 @@ pure = return (<*>) = ap +#if __GLASGOW_HASKELL__ >= 800 +runGhcT :: (MonadIO m, MonadMask m) => Maybe FilePath -> GhcT m a -> m a +#else runGhcT :: (Functor m, MonadIO m, MonadCatch m, MonadMask m) => Maybe FilePath -> GhcT m a -> m a +#endif runGhcT f = unMTLA . GHC.runGhcT f . unGhcT instance MTL.MonadTrans GhcT where diff --git a/src/Hint/Base.hs b/src/Hint/Base.hs --- a/src/Hint/Base.hs +++ b/src/Hint/Base.hs @@ -7,7 +7,7 @@ InterpreterState(..), fromState, onState, InterpreterConfiguration(..), - runGhc1, runGhc2, runGhc3, + runGhc1, runGhc2, ModuleName, PhantomModule(..), findModule, moduleIsLoaded, @@ -26,6 +26,10 @@ import qualified Hint.GHC as GHC +#if MIN_VERSION_base(4,8,0) +import qualified Data.List +#endif + import Hint.Extension -- | Version of the underlying ghc api. Values are: @@ -74,23 +78,38 @@ type InterpreterSession = SessionData () instance Exception InterpreterError +#if MIN_VERSION_base(4,8,0) + where + displayException (UnknownError err) = "UnknownError: " ++ err + displayException (WontCompile es) = unlines . Data.List.nub . map errMsg $ es + displayException (NotAllowed err) = "NotAllowed: " ++ err + displayException (GhcException err) = "GhcException: " ++ err +#endif type RunGhc m a = +#if __GLASGOW_HASKELL__ >= 800 + (forall n.(MonadIO n, MonadMask n) => GHC.GhcT n a) +#else (forall n.(MonadIO n, MonadMask n, Functor n) => GHC.GhcT n a) +#endif -> m a type RunGhc1 m a b = +#if __GLASGOW_HASKELL__ >= 800 + (forall n.(MonadIO n, MonadMask n) => a -> GHC.GhcT n b) +#else (forall n.(MonadIO n, MonadMask n, Functor n) => a -> GHC.GhcT n b) +#endif -> (a -> m b) type RunGhc2 m a b c = +#if __GLASGOW_HASKELL__ >= 800 + (forall n.(MonadIO n, MonadMask n) => a -> b -> GHC.GhcT n c) +#else (forall n.(MonadIO n, MonadMask n, Functor n) => a -> b -> GHC.GhcT n c) +#endif -> (a -> b -> m c) -type RunGhc3 m a b c d = - (forall n.(MonadIO n, MonadMask n, Functor n) => a -> b -> c -> GHC.GhcT n d) - -> (a -> b -> c -> m d) - data SessionData a = SessionData { internalState :: IORef InterpreterState, versionSpecific :: a, @@ -129,9 +148,6 @@ runGhc2 :: MonadInterpreter m => RunGhc2 m a b c runGhc2 f a = runGhc1 (f a) - -runGhc3 :: MonadInterpreter m => RunGhc3 m a b c d -runGhc3 f a = runGhc2 (f a) -- ================ Handling the interpreter state ================= diff --git a/src/Hint/Extension.hs b/src/Hint/Extension.hs --- a/src/Hint/Extension.hs +++ b/src/Hint/Extension.hs @@ -127,6 +127,18 @@ | PartialTypeSignatures | NamedWildCards | DeriveAnyClass + | DeriveLift + | StaticPointers + | StrictData + | Strict + | ApplicativeDo + | DuplicateRecordFields + | TypeApplications + | TypeInType + | UndecidableSuperClasses + | MonadFailDesugaring + | TemplateHaskellQuotes + | OverloadedLabels | NoOverlappingInstances | NoUndecidableInstances | NoIncoherentInstances @@ -233,6 +245,18 @@ | NoPartialTypeSignatures | NoNamedWildCards | NoDeriveAnyClass + | NoDeriveLift + | NoStaticPointers + | NoStrictData + | NoStrict + | NoApplicativeDo + | NoDuplicateRecordFields + | NoTypeApplications + | NoTypeInType + | NoUndecidableSuperClasses + | NoMonadFailDesugaring + | NoTemplateHaskellQuotes + | NoOverloadedLabels | UnknownExtension String deriving (Eq, Show, Read) @@ -343,6 +367,18 @@ PartialTypeSignatures, NamedWildCards, DeriveAnyClass, + DeriveLift, + StaticPointers, + StrictData, + Strict, + ApplicativeDo, + DuplicateRecordFields, + TypeApplications, + TypeInType, + UndecidableSuperClasses, + MonadFailDesugaring, + TemplateHaskellQuotes, + OverloadedLabels, NoOverlappingInstances, NoUndecidableInstances, NoIncoherentInstances, @@ -448,5 +484,17 @@ NoPatternSynonyms, NoPartialTypeSignatures, NoNamedWildCards, - NoDeriveAnyClass + NoDeriveAnyClass, + NoDeriveLift, + NoStaticPointers, + NoStrictData, + NoStrict, + NoApplicativeDo, + NoDuplicateRecordFields, + NoTypeApplications, + NoTypeInType, + NoUndecidableSuperClasses, + NoMonadFailDesugaring, + NoTemplateHaskellQuotes, + NoOverloadedLabels ] diff --git a/src/Hint/InterpreterT.hs b/src/Hint/InterpreterT.hs --- a/src/Hint/InterpreterT.hs +++ b/src/Hint/InterpreterT.hs @@ -34,8 +34,11 @@ } deriving (Functor, Monad, MonadIO, MonadThrow, MonadCatch, MonadMask) -execute :: (MonadIO m, MonadMask m, Functor m) - => String +execute :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => String -> InterpreterSession -> InterpreterT m a -> m (Either InterpreterError a) @@ -47,7 +50,11 @@ instance MonadTrans InterpreterT where lift = InterpreterT . lift . lift -runGhcImpl :: (MonadIO m, MonadThrow m, MonadMask m, Functor m) => RunGhc (InterpreterT m) a +runGhcImpl :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , MonadThrow m, Functor m +#endif + ) => RunGhc (InterpreterT m) a runGhcImpl a = InterpreterT (lift a) `catches` @@ -107,22 +114,31 @@ -- NB. The underlying ghc will overwrite certain signal handlers -- (SIGINT, SIGHUP, SIGTERM, SIGQUIT on Posix systems, Ctrl-C handler on Windows). -- In future versions of hint, this might be controlled by the user. -runInterpreter :: (MonadIO m, MonadMask m, Functor m) - => InterpreterT m a +runInterpreter :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => InterpreterT m a -> m (Either InterpreterError a) runInterpreter = runInterpreterWithArgs [] -- | Executes the interpreter, setting args passed in as though they -- were command-line args. Returns @Left InterpreterError@ in case of -- error. -runInterpreterWithArgs :: (MonadIO m, MonadMask m, Functor m) - => [String] +runInterpreterWithArgs :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => [String] -> InterpreterT m a -> m (Either InterpreterError a) runInterpreterWithArgs args = runInterpreterWithArgsLibdir args GHC.Paths.libdir -runInterpreterWithArgsLibdir :: (MonadIO m, MonadMask m, Functor m) - => [String] +runInterpreterWithArgsLibdir :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => [String] -> String -> InterpreterT m a -> m (Either InterpreterError a) @@ -134,8 +150,10 @@ newInterpreterSession = newSessionData () cleanSession = do cleanPhantomModules +#if __GLASGOW_HASKELL__ < 800 runGhc $ do dflags <- GHC.getSessionDynFlags GHC.defaultCleanupHandler dflags (return ()) +#endif {-# NOINLINE uniqueToken #-} uniqueToken :: MVar () @@ -182,7 +200,11 @@ } mkLogHandler :: IORef [GhcError] -> GhcErrLogger +#if __GLASGOW_HASKELL__ >= 800 +mkLogHandler r df _ _ src style msg = +#else mkLogHandler r df _ src style msg = +#endif let renderErrMsg = GHC.showSDoc df errorEntry = mkGhcError renderErrMsg src style msg in modifyIORef r (errorEntry :) @@ -203,6 +225,10 @@ -- runGhc = runGhcImpl +#if __GLASGOW_HASKELL__ >= 800 +instance (Monad m) => Applicative (InterpreterT m) where +#else instance (Monad m, Applicative m) => Applicative (InterpreterT m) where +#endif pure = return (<*>) = ap diff --git a/src/Hint/Parsers.hs b/src/Hint/Parsers.hs --- a/src/Hint/Parsers.hs +++ b/src/Hint/Parsers.hs @@ -8,6 +8,10 @@ import qualified Hint.GHC as GHC +#if __GLASGOW_HASKELL__ >= 800 +import qualified DynFlags as GHC +#endif + data ParseResult = ParseOk | ParseError GHC.SrcSpan GHC.Message parseExpr :: MonadInterpreter m => String -> m ParseResult @@ -50,7 +54,11 @@ dflags <- runGhc GHC.getSessionDynFlags let logger' = logger dflags errStyle = GHC.defaultErrStyle dflags - liftIO $ logger' GHC.SevError + liftIO $ logger' +#if __GLASGOW_HASKELL__ >= 800 + GHC.NoReason +#endif + GHC.SevError span errStyle err diff --git a/src/Language/Haskell/Interpreter.hs b/src/Language/Haskell/Interpreter.hs --- a/src/Language/Haskell/Interpreter.hs +++ b/src/Language/Haskell/Interpreter.hs @@ -28,7 +28,7 @@ -- ** Module querying ModuleElem(..), Id, name, children, getModuleExports, - -- ** Anotations + -- ** Annotations -- In the snippets below we use \'LBRACE\' and \'RBRACE\' -- to mean \'{\' and \'}\' respectively. We cannot put the -- pragmas inline in the code since GHC scarfs them up. diff --git a/src/Language/Haskell/Interpreter/Unsafe.hs b/src/Language/Haskell/Interpreter/Unsafe.hs --- a/src/Language/Haskell/Interpreter/Unsafe.hs +++ b/src/Language/Haskell/Interpreter/Unsafe.hs @@ -24,8 +24,11 @@ -- context. -- -- Warning: Some options may interact badly with the Interpreter. -unsafeRunInterpreterWithArgs :: (MonadMask m, MonadIO m, Functor m) - => [String] +unsafeRunInterpreterWithArgs :: (MonadMask m, MonadIO m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => [String] -> InterpreterT m a -> m (Either InterpreterError a) unsafeRunInterpreterWithArgs = runInterpreterWithArgs @@ -36,8 +39,11 @@ -- a machine in which GHC is not installed. -- -- A typical libdir value would be "/opt/ghc/7.10.3/lib/ghc-7.10.3". -unsafeRunInterpreterWithArgsLibdir :: (MonadIO m, MonadMask m, Functor m) - => [String] +unsafeRunInterpreterWithArgsLibdir :: (MonadIO m, MonadMask m +#if __GLASGOW_HASKELL__ < 800 + , Functor m +#endif + ) => [String] -> String -> InterpreterT m a -> m (Either InterpreterError a)