Merge remote-tracking branch 'kazu/master'

Conflicts: Language/Haskell/GhcMod.hs Language/Haskell/GhcMod/Check.hs Language/Haskell/GhcMod/FillSig.hs Language/Haskell/GhcMod/GHCApi.hs Language/Haskell/GhcMod/Ghc.hs src/GHCMod.hs
2014-07-16 19:01:43 +02:00
parent 49437d82d9 3050ba1863
commit 57bd408785
46 changed files with 932 additions and 726 deletions
--- a/Language/Haskell/GhcMod.hs
+++ b/Language/Haskell/GhcMod.hs
@@ -12,24 +12,25 @@ module Language.Haskell.GhcMod (
  -- * Types
  , ModuleString
  , Expression
-  -- * 'IO' utilities
-  , bootInfo
+  , GhcPkgDb
+  -- * 'GhcMod' utilities
+  , boot
  , browse
+  , check
  , checkSyntax
-  , lintSyntax
-  , expandTemplate
-  , infoExpr
-  , typeExpr
-  , fillSig
-  , refineVar
-  , listModules
-  , listLanguages
-  , listFlags
  , debugInfo
-  , rootInfo
-  , packageDoc
+  , expandTemplate
  , findSymbol
-  , splitVar
+  , info
+  , lint
+  , pkgDoc
+  , rootInfo
+  , types
+  , splits
+  , sig
+  , modules
+  , languages
+  , flags
  ) where

 import Language.Haskell.GhcMod.Boot
--- a/Language/Haskell/GhcMod/Boot.hs
+++ b/Language/Haskell/GhcMod/Boot.hs
@@ -1,27 +1,16 @@
 module Language.Haskell.GhcMod.Boot where

-import Control.Applicative ((<$>))
-import CoreMonad (liftIO, liftIO)
+import Control.Applicative
 import Language.Haskell.GhcMod.Browse
 import Language.Haskell.GhcMod.Flag
 import Language.Haskell.GhcMod.Lang
 import Language.Haskell.GhcMod.List
 import Language.Haskell.GhcMod.Monad
-import Language.Haskell.GhcMod.Types

 -- | Printing necessary information for front-end booting.
-bootInfo :: Options -> IO String
-bootInfo opt = runGhcMod opt $ boot
-
-- | Printing necessary information for front-end booting.
-boot :: GhcMod String
-boot = do
-    opt   <- options
-    mods  <- modules
-    langs <- liftIO $ listLanguages opt
-    flags <- liftIO $ listFlags opt
-    pre   <- concat <$> mapM browse preBrowsedModules
-    return $ mods ++ langs ++ flags ++ pre
+boot :: IOish m => GhcModT m String
+boot =  concat <$> sequence [modules, languages, flags,
+                             concat <$> mapM browse preBrowsedModules]

 preBrowsedModules :: [String]
 preBrowsedModules = [
--- a/Language/Haskell/GhcMod/Browse.hs
+++ b/Language/Haskell/GhcMod/Browse.hs
@@ -10,10 +10,10 @@ import Data.List (sort)
 import Data.Maybe (catMaybes)
 import Exception (ghandle)
 import FastString (mkFastString)
-import GHC (GhcException(CmdLineError), ModuleInfo, Name, TyThing, DynFlags, Type, TyCon, Module)
+import GHC (GhcException(CmdLineError), ModuleInfo, Name, TyThing, DynFlags, Type, TyCon)
 import qualified GHC as G
 import Language.Haskell.GhcMod.Doc (showPage, showOneLine, styleUnqualified)
-import Language.Haskell.GhcMod.GHCApi
+import Language.Haskell.GhcMod.DynFlags
 import Language.Haskell.GhcMod.Gap
 import Language.Haskell.GhcMod.Monad
 import Language.Haskell.GhcMod.Convert
@@ -28,8 +28,9 @@ import Type (dropForAlls, splitFunTy_maybe, mkFunTy, isPredTy)
 -- | Getting functions, classes, etc from a module.
 --   If 'detailed' is 'True', their types are also obtained.
 --   If 'operators' is 'True', operators are also returned.
-browse :: ModuleString -- ^ A module name. (e.g. \"Data.List\")
-       -> GhcMod String
+browse :: IOish m
+       => ModuleString -- ^ A module name. (e.g. \"Data.List\")
+       -> GhcModT m String
 browse pkgmdl = convert' . sort =<< (listExports =<< getModule)
  where
    (mpkg,mdl) = splitPkgMdl pkgmdl
@@ -61,7 +62,7 @@ splitPkgMdl pkgmdl = case break (==':') pkgmdl of
    (mdl,"")    -> (Nothing,mdl)
    (pkg,_:mdl) -> (Just pkg,mdl)

-processExports :: ModuleInfo -> GhcMod [String]
+processExports :: IOish m => ModuleInfo -> GhcModT m [String]
 processExports minfo = do
  opt <- options
  let
@@ -70,13 +71,13 @@ processExports minfo = do
      | otherwise = filter (isAlpha . head . getOccString)
  mapM (showExport opt minfo) $ removeOps $ G.modInfoExports minfo

-showExport :: Options -> ModuleInfo -> Name -> GhcMod String
+showExport :: IOish m => Options -> ModuleInfo -> Name -> GhcModT m String
 showExport opt minfo e = do
  mtype' <- mtype
  return $ concat $ catMaybes [mqualified, Just $ formatOp $ getOccString e, mtype']
  where
    mqualified = (G.moduleNameString (G.moduleName $ G.nameModule e) ++ ".") `justIf` qualified opt
-    mtype :: GhcMod (Maybe String)
+    mtype :: IOish m => GhcModT m (Maybe String)
    mtype
      | detailed opt = do
        tyInfo <- G.modInfoLookupName minfo e
@@ -91,7 +92,7 @@ showExport opt minfo e = do
      | isAlpha n = nm
      | otherwise = "(" ++ nm ++ ")"
    formatOp "" = error "formatOp"
-    inOtherModule :: Name -> GhcMod (Maybe TyThing)
+    inOtherModule :: IOish m => Name -> GhcModT m (Maybe TyThing)
    inOtherModule nm = G.getModuleInfo (G.nameModule nm) >> G.lookupGlobalName nm
    justIf :: a -> Bool -> Maybe a
    justIf x True = Just x
@@ -138,13 +139,13 @@ showOutputable dflag = unwords . lines . showPage dflag styleUnqualified . ppr
 ----------------------------------------------------------------

 -- | Browsing all functions in all system/user modules.
-browseAll :: DynFlags -> GhcMod [(String,String)]
+browseAll :: IOish m => DynFlags -> GhcModT m [(String,String)]
 browseAll dflag = do
    ms <- G.packageDbModules True
    is <- mapM G.getModuleInfo ms
    return $ concatMap (toNameModule dflag) (zip ms is)

-toNameModule :: DynFlags -> (Module, Maybe ModuleInfo) -> [(String,String)]
+toNameModule :: DynFlags -> (G.Module, Maybe ModuleInfo) -> [(String,String)]
 toNameModule _     (_,Nothing)  = []
 toNameModule dflag (m,Just inf) = map (\name -> (toStr name, mdl)) names
  where
--- a/Language/Haskell/GhcMod/CabalApi.hs
+++ b/Language/Haskell/GhcMod/CabalApi.hs
@@ -10,9 +10,10 @@ module Language.Haskell.GhcMod.CabalApi (
  , cabalConfigDependencies
  ) where

-import Language.Haskell.GhcMod.Types
-import Language.Haskell.GhcMod.GhcPkg
 import Language.Haskell.GhcMod.CabalConfig
+import Language.Haskell.GhcMod.Gap (benchmarkBuildInfo, benchmarkTargets, toModuleString)
+import Language.Haskell.GhcMod.GhcPkg
+import Language.Haskell.GhcMod.Types

 import Control.Applicative ((<$>))
 import qualified Control.Exception as E
@@ -20,7 +21,6 @@ import Control.Monad (filterM)
 import CoreMonad (liftIO)
 import Data.Maybe (maybeToList)
 import Data.Set (fromList, toList)
-import Distribution.ModuleName (ModuleName,toFilePath)
 import Distribution.Package (Dependency(Dependency)
                           , PackageName(PackageName))
 import qualified Distribution.Package as C
@@ -119,11 +119,7 @@ cabalAllBuildInfo pd = libBI ++ execBI ++ testBI ++ benchBI
    libBI   = map P.libBuildInfo       $ maybeToList $ P.library pd
    execBI  = map P.buildInfo          $ P.executables pd
    testBI  = map P.testBuildInfo      $ P.testSuites pd
-#if __GLASGOW_HASKELL__ >= 704
-    benchBI = map P.benchmarkBuildInfo $ P.benchmarks pd
-#else
-    benchBI = []
-#endif
+    benchBI = benchmarkBuildInfo pd

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

@@ -172,16 +168,7 @@ cabalAllTargets pd = do
            Just l -> P.libModules l

    libTargets = map toModuleString lib
-#if __GLASGOW_HASKELL__ >= 704
-    benchTargets = map toModuleString $ concatMap P.benchmarkModules $ P.benchmarks  pd
-#else
-    benchTargets = []
-#endif
-    toModuleString :: ModuleName -> String
-    toModuleString mn = fromFilePath $ toFilePath mn
-
-    fromFilePath :: FilePath -> String
-    fromFilePath fp = map (\c -> if c=='/' then '.' else c) fp
+    benchTargets = benchmarkTargets pd

    getTestTarget :: TestSuite -> IO [String]
    getTestTarget ts =
--- a/Language/Haskell/GhcMod/CaseSplit.hs
+++ b/Language/Haskell/GhcMod/CaseSplit.hs
@@ -1,28 +1,24 @@
 {-# LANGUAGE CPP #-}

 module Language.Haskell.GhcMod.CaseSplit (
-    splitVar
-  , splits
+    splits
  ) where

+import CoreMonad (liftIO)
 import Data.List (find, intercalate)
 import qualified Data.Text as T
 import qualified Data.Text.IO as T (readFile)
+import qualified DataCon as Ty
 import Exception (ghandle, SomeException(..))
-import GHC (GhcMonad, LHsBind, LHsExpr, LPat, Id, ParsedModule(..), TypecheckedModule(..), DynFlags, SrcSpan, Type, GenLocated(L))
+import GHC (GhcMonad, LHsBind, LPat, Id, ParsedModule(..), TypecheckedModule(..), DynFlags, SrcSpan, Type, GenLocated(L))
 import qualified GHC as G
-import Language.Haskell.GhcMod.GHCApi
-import Language.Haskell.GhcMod.Gap (HasType(..))
+import Language.Haskell.GhcMod.Convert
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Monad
 import Language.Haskell.GhcMod.SrcUtils
-import Language.Haskell.GhcMod.Types
-import Language.Haskell.GhcMod.Convert
-import MonadUtils (liftIO)
 import Outputable (PprStyle)
-import qualified Type as Ty
 import qualified TyCon as Ty
-import qualified DataCon as Ty
+import qualified Type as Ty

 ----------------------------------------------------------------
 -- CASE SPLITTING
@@ -36,21 +32,11 @@ data SplitToTextInfo = SplitToTextInfo { sVarName     :: String
                                       }

 -- | Splitting a variable in a equation.
-splitVar :: Options
-         -> Cradle
-         -> FilePath     -- ^ A target file.
-         -> Int          -- ^ Line number.
-         -> Int          -- ^ Column number.
-         -> IO String
-splitVar opt cradle file lineNo colNo = runGhcMod opt $ do
-    initializeFlagsWithCradle opt cradle
-    splits file lineNo colNo
-
-- | Splitting a variable in a equation.
-splits :: FilePath     -- ^ A target file.
+splits :: IOish m
+       => FilePath     -- ^ A target file.
       -> Int          -- ^ Line number.
       -> Int          -- ^ Column number.
-       -> GhcMod String
+       -> GhcModT m String
 splits file lineNo colNo = ghandle handler body
  where
    body = inModuleContext file $ \dflag style -> do
@@ -73,17 +59,12 @@ getSrcSpanTypeForSplit modSum lineNo colNo = do
    tcm@TypecheckedModule{tm_typechecked_source = tcs} <- G.typecheckModule p
    let bs:_ = listifySpans tcs (lineNo, colNo) :: [LHsBind Id]
        varPat  = find isPatternVar $ listifySpans tcs (lineNo, colNo) :: Maybe (LPat Id)
-        match:_ = listifyParsedSpans pms (lineNo, colNo)
-#if __GLASGOW_HASKELL__ < 708
-                    :: [G.LMatch G.RdrName]
-#else
-                    :: [G.LMatch G.RdrName (LHsExpr G.RdrName)]
-#endif
+        match:_ = listifyParsedSpans pms (lineNo, colNo) :: [Gap.GLMatch]
    case varPat of
      Nothing  -> return Nothing
      Just varPat' -> do
-        varT <- getType tcm varPat'  -- Finally we get the type of the var
-        bsT  <- getType tcm bs
+        varT <- Gap.getType tcm varPat'  -- Finally we get the type of the var
+        bsT  <- Gap.getType tcm bs
        case (varT, bsT) of
          (Just varT', Just (_,bsT')) ->
            let (L matchL (G.Match _ _ (G.GRHSs rhsLs _))) = match
@@ -212,7 +193,7 @@ srcSpanDifference b v =
   in (vsl - bsl, vsc - bsc, vel - bsl, vec - bsc) -- assume variable in one line

 replaceVarWithTyCon :: [T.Text] -> (Int,Int,Int,Int) -> String -> String -> [T.Text]
-replaceVarWithTyCon text (vsl,vsc,_,vec) varname tycon = 
+replaceVarWithTyCon text (vsl,vsc,_,vec) varname tycon =
  let tycon'      = if ' ' `elem` tycon || ':' `elem` tycon then "(" ++ tycon ++ ")" else tycon
      lengthDiff  = length tycon' - length varname
      tycon''     = T.pack $ if lengthDiff < 0 then tycon' ++ replicate (-lengthDiff) ' ' else tycon'
--- a/Language/Haskell/GhcMod/Check.hs
+++ b/Language/Haskell/GhcMod/Check.hs
@@ -6,7 +6,7 @@ module Language.Haskell.GhcMod.Check (
  ) where

 import Control.Applicative ((<$>))
-import Language.Haskell.GhcMod.GHCApi
+import Language.Haskell.GhcMod.DynFlags
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Logger
 import Language.Haskell.GhcMod.Monad
@@ -15,8 +15,9 @@ import Language.Haskell.GhcMod.Monad

 -- | Checking syntax of a target file using GHC.
 --   Warnings and errors are returned.
-checkSyntax :: [FilePath]  -- ^ The target files.
-            -> GhcMod String
+checkSyntax :: IOish m
+            => [FilePath]  -- ^ The target files.
+            -> GhcModT m String
 checkSyntax [] = return ""
 checkSyntax files = withErrorHandler sessionName $ do
    either id id <$> check files
@@ -29,17 +30,19 @@ checkSyntax files = withErrorHandler sessionName $ do

 -- | Checking syntax of a target file using GHC.
 --   Warnings and errors are returned.
-check :: [FilePath]  -- ^ The target files.
-      -> GhcMod (Either String String)
+check :: IOish m
+      => [FilePath]  -- ^ The target files.
+      -> GhcModT m (Either String String)
 check fileNames = do
-  withLogger (setAllWaringFlags . setNoMaxRelevantBindings) $ do
+  withLogger (setAllWaringFlags . setNoMaxRelevantBindings) $
    setTargetFiles fileNames

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

 -- | Expanding Haskell Template.
-expandTemplate :: [FilePath]  -- ^ The target files.
-               -> GhcMod String
+expandTemplate :: IOish m
+               => [FilePath]  -- ^ The target files.
+               -> GhcModT m String
 expandTemplate [] = return ""
 expandTemplate files = withErrorHandler sessionName $ do
    either id id <$> expand files
@@ -51,7 +54,8 @@ expandTemplate files = withErrorHandler sessionName $ do
 ----------------------------------------------------------------

 -- | Expanding Haskell Template.
-expand :: [FilePath]  -- ^ The target files.
-      -> GhcMod (Either String String)
+expand :: IOish m
+       => [FilePath]  -- ^ The target files.
+       -> GhcModT m (Either String String)
 expand fileNames = withLogger (Gap.setDumpSplices . setNoWaringFlags) $
    setTargetFiles fileNames
--- a/Language/Haskell/GhcMod/Convert.hs
+++ b/Language/Haskell/GhcMod/Convert.hs
@@ -23,7 +23,7 @@ inter :: Char -> [Builder] -> Builder
 inter _ [] = id
 inter c bs = foldr1 (\x y -> x . (c:) . y) bs

-convert' :: ToString a => a -> GhcMod String
+convert' :: (ToString a, IOish m) => a -> GhcModT m String
 convert' x = flip convert x <$> options

 convert :: ToString a => Options -> a -> String
--- a/Language/Haskell/GhcMod/Cradle.hs
+++ b/Language/Haskell/GhcMod/Cradle.hs
@@ -1,5 +1,6 @@
 module Language.Haskell.GhcMod.Cradle (
    findCradle
+  , findCradle'
  , findCradleWithoutSandbox
  ) where

@@ -22,8 +23,10 @@ import System.FilePath ((</>), takeDirectory)
 --   in a cabal directory.
 findCradle :: IO Cradle
 findCradle = do
-    wdir <- getCurrentDirectory
-    cabalCradle wdir ||> sandboxCradle wdir ||> plainCradle wdir
+    findCradle' =<< getCurrentDirectory
+
+findCradle' :: FilePath -> IO Cradle
+findCradle' dir = cabalCradle dir ||> sandboxCradle dir ||> plainCradle dir

 cabalCradle :: FilePath -> IO Cradle
 cabalCradle wdir = do
--- a/Language/Haskell/GhcMod/Debug.hs
+++ b/Language/Haskell/GhcMod/Debug.hs
@@ -1,55 +1,42 @@
 module Language.Haskell.GhcMod.Debug (debugInfo, rootInfo) where

 import Control.Applicative ((<$>))
-import Control.Exception.IOChoice ((||>))
 import CoreMonad (liftIO)
 import Data.List (intercalate)
-import Data.Maybe (fromMaybe, isJust, fromJust)
-import Language.Haskell.GhcMod.CabalApi
-import Language.Haskell.GhcMod.GHCApi
+import Data.Maybe (isJust, fromJust)
 import Language.Haskell.GhcMod.Convert
+import Language.Haskell.GhcMod.Monad
 import Language.Haskell.GhcMod.Types
+import Language.Haskell.GhcMod.Internal

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

 -- | Obtaining debug information.
-debugInfo :: Options
-          -> Cradle
-          -> IO String
-debugInfo opt cradle = convert opt <$> do
+debugInfo :: IOish m => GhcModT m String
+debugInfo = cradle >>= \c -> convert' =<< do
    CompilerOptions gopts incDir pkgs <-
-        if cabal then
-            liftIO (fromCabalFile ||> return simpleCompilerOption)
+        if isJust $ cradleCabalFile c then
+            (fromCabalFile c ||> simpleCompilerOption)
          else
-            return simpleCompilerOption
-    mglibdir <- liftIO getSystemLibDir
+            simpleCompilerOption
    return [
-        "Root directory:      " ++ rootDir
-      , "Current directory:   " ++ currentDir
-      , "Cabal file:          " ++ cabalFile
+        "Root directory:      " ++ cradleRootDir c
+      , "Current directory:   " ++ cradleCurrentDir c
+      , "Cabal file:          " ++ show (cradleCabalFile c)
      , "GHC options:         " ++ unwords gopts
      , "Include directories: " ++ unwords incDir
      , "Dependent packages:  " ++ intercalate ", " (map showPkg pkgs)
-      , "System libraries:    " ++ fromMaybe "" mglibdir
+      , "System libraries:    " ++ ghcLibDir
      ]
  where
-    currentDir = cradleCurrentDir cradle
-    mCabalFile = cradleCabalFile cradle
-    rootDir    = cradleRootDir cradle
-    cabal = isJust mCabalFile
-    cabalFile = fromMaybe "" mCabalFile
-    origGopts = ghcOpts opt
-    simpleCompilerOption = CompilerOptions origGopts [] []
-    fromCabalFile = do
-        pkgDesc <- parseCabalFile file
-        getCompilerOptions origGopts cradle pkgDesc
-      where
-        file = fromJust mCabalFile
+    simpleCompilerOption = options >>= \op ->
+        return $ CompilerOptions (ghcOpts op) [] []
+    fromCabalFile c = options >>= \opts -> liftIO $ do
+        pkgDesc <- parseCabalFile $ fromJust $ cradleCabalFile c
+        getCompilerOptions (ghcOpts opts) c pkgDesc

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

 -- | Obtaining root information.
-rootInfo :: Options
-          -> Cradle
-          -> IO String
-rootInfo opt cradle = return $ convert opt $ cradleRootDir cradle
+rootInfo :: IOish m => GhcModT m String
+rootInfo = convert' =<< cradleRootDir <$> cradle
--- a/Language/Haskell/GhcMod/DynFlags.hs
+++ b/Language/Haskell/GhcMod/DynFlags.hs
@@ -0,0 +1,155 @@
+{-# LANGUAGE CPP #-}
+
+module Language.Haskell.GhcMod.DynFlags where
+
+import qualified Language.Haskell.GhcMod.Gap as Gap
+import Language.Haskell.GhcMod.Types
+
+import Control.Applicative ((<$>))
+import Control.Monad (forM, void, (>=>))
+import GHC (DynFlags(..), GhcMode(..), GhcLink(..), HscTarget(..), LoadHowMuch(..))
+import qualified GHC as G
+import GhcMonad
+import GHC.Paths (libdir)
+import DynFlags (ExtensionFlag(..), xopt)
+
+import System.IO.Unsafe (unsafePerformIO)
+
+data Build = CabalPkg | SingleFile deriving Eq
+
+setEmptyLogger :: DynFlags -> DynFlags
+setEmptyLogger df = Gap.setLogAction df $ \_ _ _ _ _ -> return ()
+
+-- Fast
+-- Friendly to foreign export
+-- Not friendly to Template Haskell
+-- Uses small memory
+setModeSimple :: DynFlags -> DynFlags
+setModeSimple df = df {
+    ghcMode   = CompManager
+  , ghcLink   = NoLink
+  , hscTarget = HscNothing
+  , optLevel  = 0
+  }
+
+-- Slow
+-- Not friendly to foreign export
+-- Friendly to Template Haskell
+-- Uses large memory
+setModeIntelligent :: DynFlags -> DynFlags
+setModeIntelligent df = df {
+    ghcMode   = CompManager
+  , ghcLink   = LinkInMemory
+  , hscTarget = HscInterpreted
+  , optLevel  = 0
+  }
+
+setIncludeDirs :: [IncludeDir] -> DynFlags -> DynFlags
+setIncludeDirs idirs df = df { importPaths = idirs }
+
+setBuildEnv :: Build -> DynFlags -> DynFlags
+setBuildEnv build = setHideAllPackages build . setCabalPackage build
+
+-- At the moment with this option set ghc only prints different error messages,
+-- suggesting the user to add a hidden package to the build-depends in his cabal
+-- file for example
+setCabalPackage :: Build -> DynFlags -> DynFlags
+setCabalPackage CabalPkg df = Gap.setCabalPkg df
+setCabalPackage _ df = df
+
+-- | Enable hiding of all package not explicitly exposed (like Cabal does)
+setHideAllPackages :: Build -> DynFlags -> DynFlags
+setHideAllPackages CabalPkg df = Gap.setHideAllPackages df
+setHideAllPackages _ df = df
+
+-- | Parse command line ghc options and add them to the 'DynFlags' passed
+addCmdOpts :: GhcMonad m => [GHCOption] -> DynFlags -> m DynFlags
+addCmdOpts cmdOpts df =
+    tfst <$> G.parseDynamicFlags df (map G.noLoc cmdOpts)
+  where
+    tfst (a,_,_) = a
+
+----------------------------------------------------------------
+
+-- | Set the files as targets and load them.
+setTargetFiles :: (GhcMonad m) => [FilePath] -> m ()
+setTargetFiles files = do
+    targets <- forM files $ \file -> G.guessTarget file Nothing
+    G.setTargets targets
+    xs <- G.depanal [] False
+    -- FIXME, checking state
+    loadTargets $ needsFallback xs
+  where
+    loadTargets False = do
+        -- Reporting error A and error B
+        void $ G.load LoadAllTargets
+        mss <- filter (\x -> G.ms_hspp_file x `elem` files) <$> G.getModuleGraph
+        -- Reporting error B and error C
+        mapM_ (G.parseModule >=> G.typecheckModule >=> G.desugarModule) mss
+        -- Error B duplicates. But we cannot ignore both error reportings,
+        -- sigh. So, the logger makes log messages unique by itself.
+    loadTargets True = do
+        df <- G.getSessionDynFlags
+        void $ G.setSessionDynFlags (setModeIntelligent df)
+        void $ G.load LoadAllTargets
+
+needsFallback :: G.ModuleGraph -> Bool
+needsFallback = any (hasTHorQQ . G.ms_hspp_opts)
+  where
+    hasTHorQQ :: DynFlags -> Bool
+    hasTHorQQ dflags = any (`xopt` dflags) [Opt_TemplateHaskell, Opt_QuasiQuotes]
+
+----------------------------------------------------------------
+
+-- | Return the 'DynFlags' currently in use in the GHC session.
+getDynamicFlags :: IO DynFlags
+getDynamicFlags = do
+    G.runGhc (Just libdir) G.getSessionDynFlags
+
+withDynFlags :: GhcMonad m
+             => (DynFlags -> DynFlags)
+             -> m a
+             -> m a
+withDynFlags setFlags body = G.gbracket setup teardown (\_ -> body)
+  where
+    setup = do
+        dflags <- G.getSessionDynFlags
+        void $ G.setSessionDynFlags (setFlags dflags)
+        return dflags
+    teardown = void . G.setSessionDynFlags
+
+withCmdFlags :: GhcMonad m => [GHCOption] -> m a -> m a
+withCmdFlags flags body = G.gbracket setup teardown (\_ -> body)
+  where
+    setup = do
+        dflags <- G.getSessionDynFlags >>= addCmdOpts flags
+        void $ G.setSessionDynFlags dflags
+        return dflags
+    teardown = void . G.setSessionDynFlags
+
+----------------------------------------------------------------
+
+-- | Set 'DynFlags' equivalent to "-w:".
+setNoWaringFlags :: DynFlags -> DynFlags
+setNoWaringFlags df = df { warningFlags = Gap.emptyWarnFlags}
+
+-- | Set 'DynFlags' equivalent to "-Wall".
+setAllWaringFlags :: DynFlags -> DynFlags
+setAllWaringFlags df = df { warningFlags = allWarningFlags }
+
+allWarningFlags :: Gap.WarnFlags
+allWarningFlags = unsafePerformIO $ do
+    G.runGhc (Just libdir) $ do
+        df <- G.getSessionDynFlags
+        df' <- addCmdOpts ["-Wall"] df
+        return $ G.warningFlags df'
+
+----------------------------------------------------------------
+
+-- | Set 'DynFlags' equivalent to "-fno-max-relevant-bindings".
+setNoMaxRelevantBindings :: DynFlags -> DynFlags
+#if __GLASGOW_HASKELL__ >= 708
+setNoMaxRelevantBindings df = df { maxRelevantBinds = Nothing }
+#else
+setNoMaxRelevantBindings = id
+#endif
--- a/Language/Haskell/GhcMod/FillSig.hs
+++ b/Language/Haskell/GhcMod/FillSig.hs
@@ -1,10 +1,7 @@
 {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, CPP #-}

 module Language.Haskell.GhcMod.FillSig (
-    fillSig
-  , sig
-  , refineVar
-  , refine
+    sig
  ) where

 import Data.Char (isSymbol)
@@ -12,23 +9,16 @@ import Data.List (find, intercalate)
 import Exception (ghandle, SomeException(..))
 import GHC (GhcMonad, Id, ParsedModule(..), TypecheckedModule(..), DynFlags, SrcSpan, Type, GenLocated(L))
 import qualified GHC as G
-import Language.Haskell.GhcMod.GHCApi
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Convert
 import Language.Haskell.GhcMod.Monad
 import Language.Haskell.GhcMod.SrcUtils
 import Language.Haskell.GhcMod.Types
-import MonadUtils (liftIO)
+import CoreMonad (liftIO)
 import Outputable (PprStyle)
 import qualified Type as Ty
 import qualified HsBinds as Ty
 import qualified Class as Ty
-#if __GLASGOW_HASKELL__ >= 706
-import OccName (occName)
-#else
-import OccName (OccName)
-import RdrName (rdrNameOcc)
-#endif
 import qualified Language.Haskell.Exts.Annotated as HE

 ----------------------------------------------------------------
@@ -40,24 +30,14 @@ data SigInfo = Signature SrcSpan [G.RdrName] (G.HsType G.RdrName)
             | InstanceDecl SrcSpan G.Class

 -- Signature for fallback operation via haskell-src-exts
-data HESigInfo = HESignature HE.SrcSpan [HE.Name HE.SrcSpanInfo] (HE.Type HE.SrcSpanInfo) 
+data HESigInfo = HESignature HE.SrcSpan [HE.Name HE.SrcSpanInfo] (HE.Type HE.SrcSpanInfo)

 -- | Create a initial body from a signature.
-fillSig :: Options
-        -> Cradle
-        -> FilePath     -- ^ A target file.
-        -> Int          -- ^ Line number.
-        -> Int          -- ^ Column number.
-        -> IO String
-fillSig opt cradle file lineNo colNo = runGhcMod opt $ do
-    initializeFlagsWithCradle opt cradle
-    sig file lineNo colNo
-
-- | Create a initial body from a signature.
-sig :: FilePath     -- ^ A target file.
+sig :: IOish m
+    => FilePath     -- ^ A target file.
    -> Int          -- ^ Line number.
    -> Int          -- ^ Column number.
-    -> GhcMod String
+    -> GhcModT m String
 sig file lineNo colNo = ghandle handler body
  where
    body = inModuleContext file $ \dflag style -> do
@@ -69,13 +49,13 @@ sig file lineNo colNo = ghandle handler body
          InstanceDecl loc cls -> do
             ("instance", fourInts loc, map (\x -> initialBody dflag style (G.idType x) x)
                                            (Ty.classMethods cls))
-            
+
    handler (SomeException _) = do
      opt <- options
      -- Code cannot be parsed by ghc module
      -- Fallback: try to get information via haskell-src-exts
      whenFound opt (getSignatureFromHE file lineNo colNo) $
-        \(HESignature loc names ty) -> 
+        \(HESignature loc names ty) ->
           ("function", fourIntsHE loc, map (initialBody undefined undefined ty) names)

 ----------------------------------------------------------------
@@ -94,32 +74,9 @@ getSignature modSum lineNo colNo = do
        -- We found an instance declaration
        TypecheckedModule{tm_renamed_source = Just tcs
                         ,tm_checked_module_info = minfo} <- G.typecheckModule p
-        case listifyRenamedSpans tcs (lineNo, colNo) :: [G.LInstDecl G.Name] of
-          -- Instance declarations of sort 'instance F (G a)'
-#if __GLASGOW_HASKELL__ >= 708
-          [L loc (G.ClsInstD (G.ClsInstDecl {G.cid_poly_ty =
-            (L _ (G.HsForAllTy _ _ _ (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _))))}))] ->
-#elif __GLASGOW_HASKELL__ >= 706
-          [L loc (G.ClsInstD
-            (L _ (G.HsForAllTy _ _ _ (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _)))) _ _ _)] ->
-#else
-          [L loc (G.InstDecl
-            (L _ (G.HsForAllTy _ _ _ (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _)))) _ _ _)] ->
-#endif
-               obtainClassInfo minfo clsName loc
-          -- Instance declarations of sort 'instance F G' (no variables)
-#if __GLASGOW_HASKELL__ >= 708
-          [L loc (G.ClsInstD (G.ClsInstDecl {G.cid_poly_ty =
-            (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _))}))] ->
-#elif __GLASGOW_HASKELL__ >= 706
-          [L loc (G.ClsInstD
-            (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _)) _ _ _)] ->
-#else
-          [L loc (G.InstDecl
-            (L _ (G.HsAppTy (L _ (G.HsTyVar clsName)) _)) _ _ _)] ->
-#endif
-               obtainClassInfo minfo clsName loc
-          _ -> return Nothing
+        case Gap.getClass $ listifyRenamedSpans tcs (lineNo, colNo) of
+            Just (clsName,loc) -> obtainClassInfo minfo clsName loc
+            Nothing            -> return Nothing
      _ -> return Nothing
  where obtainClassInfo :: GhcMonad m => G.ModuleInfo -> G.Name -> SrcSpan -> m (Maybe SigInfo)
        obtainClassInfo minfo clsName loc = do
@@ -173,7 +130,7 @@ class FnArgsInfo ty name | ty -> name, name -> ty where
  getFnArgs :: ty -> [FnArg]

 instance FnArgsInfo (G.HsType G.RdrName) (G.RdrName) where
-  getFnName dflag style name = showOccName dflag style $ occName name
+  getFnName dflag style name = showOccName dflag style $ Gap.occName name
  getFnArgs (G.HsForAllTy _ _ _ (L _ iTy))  = getFnArgs iTy
  getFnArgs (G.HsParTy (L _ iTy))           = getFnArgs iTy
  getFnArgs (G.HsFunTy (L _ lTy) (L _ rTy)) = (if fnarg lTy then FnArgFunction else FnArgNormal):getFnArgs rTy
@@ -184,11 +141,6 @@ instance FnArgsInfo (G.HsType G.RdrName) (G.RdrName) where
                           _                              -> False
  getFnArgs _ = []

-#if __GLASGOW_HASKELL__ < 706
-occName :: G.RdrName -> OccName
-occName = rdrNameOcc
-#endif
-
 instance FnArgsInfo (HE.Type HE.SrcSpanInfo) (HE.Name HE.SrcSpanInfo) where
  getFnName _ _ (HE.Ident  _ s) = s
  getFnName _ _ (HE.Symbol _ s) = s
@@ -229,23 +181,13 @@ isSymbolName []    = error "This should never happen"
 -- REWRITE A HOLE / UNDEFINED VIA A FUNCTION
 ----------------------------------------------------------------

-- | Create a initial body from a signature.
-refineVar :: Options
-          -> Cradle
-          -> FilePath     -- ^ A target file.
-          -> Int          -- ^ Line number.
-          -> Int          -- ^ Column number.
-          -> Expression   -- ^ A Haskell expression.
-          -> IO String
-refineVar opt cradle file lineNo colNo e = runGhcMod opt $ do
-    initializeFlagsWithCradle opt cradle
-    refine file lineNo colNo e
-
-refine :: FilePath     -- ^ A target file.
+{-
+refine :: IOish m
+       => FilePath     -- ^ A target file.
       -> Int          -- ^ Line number.
       -> Int          -- ^ Column number.
       -> Expression   -- ^ A Haskell expression.
-       -> GhcMod String
+       -> GhcModT m String
 refine file lineNo colNo expr = ghandle handler body
  where
    body = inModuleContext file $ \dflag style -> do
@@ -273,3 +215,4 @@ findVar modSum lineNo colNo = do
   case listifyParsedSpans ps (lineNo, colNo) :: [G.LHsExpr G.RdrName] of
     (L loc (G.HsVar _)):_ -> return $ Just loc
     _                     -> return Nothing
+-}
--- a/Language/Haskell/GhcMod/Find.hs
+++ b/Language/Haskell/GhcMod/Find.hs
@@ -31,11 +31,11 @@ type Symbol = String
 newtype SymMdlDb = SymMdlDb (Map Symbol [ModuleString])

 -- | Finding modules to which the symbol belong.
-findSymbol :: Symbol -> GhcMod String
+findSymbol :: IOish m => Symbol -> GhcModT m String
 findSymbol sym = convert' =<< lookupSym sym <$> getSymMdlDb

 -- | Creating 'SymMdlDb'.
-getSymMdlDb :: GhcMod SymMdlDb
+getSymMdlDb :: IOish m => GhcModT m SymMdlDb
 getSymMdlDb = do
    sm <- G.getSessionDynFlags >>= browseAll
 #if MIN_VERSION_containers(0,5,0)
--- a/Language/Haskell/GhcMod/Flag.hs
+++ b/Language/Haskell/GhcMod/Flag.hs
@@ -2,12 +2,12 @@ module Language.Haskell.GhcMod.Flag where

 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Convert
-import Language.Haskell.GhcMod.Types
+import Language.Haskell.GhcMod.Monad

 -- | Listing GHC flags. (e.g -fno-warn-orphans)

-listFlags :: Options -> IO String
-listFlags opt = return $ convert opt [ "-f" ++ prefix ++ option
-                                     | option <- Gap.fOptions
-                                     , prefix <- ["","no-"]
-                                     ]
+flags :: IOish m => GhcModT m String
+flags = convert' [ "-f" ++ prefix ++ option
+                 | option <- Gap.fOptions
+                 , prefix <- ["","no-"]
+                 ]
--- a/Language/Haskell/GhcMod/GHCApi.hs
+++ b/Language/Haskell/GhcMod/GHCApi.hs
@@ -1,214 +1,87 @@
 {-# LANGUAGE ScopedTypeVariables, RecordWildCards, CPP #-}

 module Language.Haskell.GhcMod.GHCApi (
-    withGHC
-  , withGHC'
-  , initializeFlagsWithCradle
-  , setTargetFiles
-  , getDynamicFlags
-  , getSystemLibDir
-  , withDynFlags
-  , withCmdFlags
-  , setNoWaringFlags
-  , setAllWaringFlags
-  , setNoMaxRelevantBindings
+    ghcPkgDb
+  , package
+  , modules
+  , findModule
+  , moduleInfo
+  , localModuleInfo
+  , bindings
  ) where

-import Language.Haskell.GhcMod.CabalApi
-import Language.Haskell.GhcMod.GHCChoice
 import Language.Haskell.GhcMod.GhcPkg
+import Language.Haskell.GhcMod.DynFlags
+import Language.Haskell.GhcMod.Types

 import Control.Applicative ((<$>))
-import Control.Monad (forM, void)
-import Data.Maybe (isJust, fromJust)
-import Exception (ghandle, SomeException(..))
-import GHC (DynFlags(..), GhcLink(..), HscTarget(..), LoadHowMuch(..))
+import Distribution.Package (InstalledPackageId(..))
+import qualified Data.Map as M
+import GHC (DynFlags(..))
 import qualified GHC as G
 import GhcMonad
-import GHC.Paths (libdir)
-import qualified Language.Haskell.GhcMod.Gap as Gap
-import Language.Haskell.GhcMod.Types
-import System.Exit (exitSuccess)
-import System.IO (hPutStr, hPrint, stderr)
-import System.IO.Unsafe (unsafePerformIO)
+import qualified Packages as G
+import qualified Module as G
+import qualified OccName as G

 ----------------------------------------------------------------
+-- get Packages,Modules,Bindings

-- | Obtaining the directory for system libraries.
-getSystemLibDir :: IO (Maybe FilePath)
-getSystemLibDir = return $ Just libdir
+ghcPkgDb :: GhcMonad m => m PkgDb
+ghcPkgDb = M.fromList <$>
+    maybe [] (map toKv . filterInternal) <$> pkgDatabase <$> G.getSessionDynFlags
+ where
+    toKv pkg = (fromInstalledPackageId $ G.installedPackageId pkg, pkg)
+    filterInternal =
+        filter ((/= InstalledPackageId "builtin_rts") . G.installedPackageId)

----------------------------------------------------------------
+package :: G.PackageConfig -> Package
+package = fromInstalledPackageId . G.installedPackageId

-- | Converting the 'Ghc' monad to the 'IO' monad.
-withGHC :: FilePath  -- ^ A target file displayed in an error message.
-        -> Ghc a -- ^ 'Ghc' actions created by the Ghc utilities.
-        -> IO a
-withGHC file body = ghandle ignore $ withGHC' body
-  where
-    ignore :: SomeException -> IO a
-    ignore e = do
-        hPutStr stderr $ file ++ ":0:0:Error:"
-        hPrint stderr e
-        exitSuccess
+modules :: G.PackageConfig -> [ModuleString]
+modules = map G.moduleNameString . G.exposedModules

-withGHC' :: Ghc a -> IO a
-withGHC' body = do
-    mlibdir <- getSystemLibDir
-    G.runGhc mlibdir $ do
-        dflags <- G.getSessionDynFlags
-        G.defaultCleanupHandler dflags body
-
----------------------------------------------------------------
-
-importDirs :: [IncludeDir]
-importDirs = [".","..","../..","../../..","../../../..","../../../../.."]
-
-data Build = CabalPkg | SingleFile deriving Eq
-
-- | Initialize the 'DynFlags' relating to the compilation of a single
-- file or GHC session according to the 'Cradle' and 'Options'
-- provided.
-initializeFlagsWithCradle :: GhcMonad m
-        => Options
-        -> Cradle
-        -> m ()
-initializeFlagsWithCradle opt cradle
-  | cabal     = withCabal |||> withSandbox
-  | otherwise = withSandbox
-  where
-    mCradleFile = cradleCabalFile cradle
-    cabal = isJust mCradleFile
-    ghcopts = ghcOpts opt
-    withCabal = do
-        pkgDesc <- liftIO $ parseCabalFile $ fromJust mCradleFile
-        compOpts <- liftIO $ getCompilerOptions ghcopts cradle pkgDesc
-        initSession CabalPkg opt compOpts
-    withSandbox = initSession SingleFile opt compOpts
-      where
-        pkgOpts = ghcDbStackOpts $ cradlePkgDbStack cradle
-        compOpts
-          | null pkgOpts = CompilerOptions ghcopts importDirs []
-          | otherwise    = CompilerOptions (ghcopts ++ pkgOpts) [wdir,rdir] []
-        wdir = cradleCurrentDir cradle
-        rdir = cradleRootDir    cradle
-
----------------------------------------------------------------
-
-initSession :: GhcMonad m
-            => Build
-            -> Options
-            -> CompilerOptions
-            -> m ()
-initSession build Options {..} CompilerOptions {..} = do
-    df <- G.getSessionDynFlags
-    void $ G.setSessionDynFlags =<< (addCmdOpts ghcOptions
-      $ setLinkerOptions
-      $ setIncludeDirs includeDirs
-      $ setBuildEnv build
-      $ setEmptyLogger
-      $ Gap.addPackageFlags depPackages df)
-
-setEmptyLogger :: DynFlags -> DynFlags
-setEmptyLogger df = Gap.setLogAction df $ \_ _ _ _ _ -> return ()
-
----------------------------------------------------------------
-
-- we don't want to generate object code so we compile to bytecode
-- (HscInterpreted) which implies LinkInMemory
-- HscInterpreted
-setLinkerOptions :: DynFlags -> DynFlags
-setLinkerOptions df = df {
-    ghcLink   = LinkInMemory
-  , hscTarget = HscInterpreted
-  }
-
-setIncludeDirs :: [IncludeDir] -> DynFlags -> DynFlags
-setIncludeDirs idirs df = df { importPaths = idirs }
-
-setBuildEnv :: Build -> DynFlags -> DynFlags
-setBuildEnv build = setHideAllPackages build . setCabalPackage build
-
-- At the moment with this option set ghc only prints different error messages,
-- suggesting the user to add a hidden package to the build-depends in his cabal
-- file for example
-setCabalPackage :: Build -> DynFlags -> DynFlags
-setCabalPackage CabalPkg df = Gap.setCabalPkg df
-setCabalPackage _ df = df
-
-- | Enable hiding of all package not explicitly exposed (like Cabal does)
-setHideAllPackages :: Build -> DynFlags -> DynFlags
-setHideAllPackages CabalPkg df = Gap.setHideAllPackages df
-setHideAllPackages _ df = df
-
-- | Parse command line ghc options and add them to the 'DynFlags' passed
-addCmdOpts :: GhcMonad m => [GHCOption] -> DynFlags -> m DynFlags
-addCmdOpts cmdOpts df =
-    tfst <$> G.parseDynamicFlags df (map G.noLoc cmdOpts)
-  where
-    tfst (a,_,_) = a
-
----------------------------------------------------------------
-
-- | Set the files as targets and load them.
-setTargetFiles :: (GhcMonad m) => [FilePath] -> m ()
-setTargetFiles files = do
-    targets <- forM files $ \file -> G.guessTarget file Nothing
-    G.setTargets targets
-    void $ G.load LoadAllTargets
-
----------------------------------------------------------------
-
-- | Return the 'DynFlags' currently in use in the GHC session.
-getDynamicFlags :: IO DynFlags
-getDynamicFlags = do
-    mlibdir <- getSystemLibDir
-    G.runGhc mlibdir G.getSessionDynFlags
-
-withDynFlags :: GhcMonad m
-             => (DynFlags -> DynFlags)
-             -> m a
-             -> m a
-withDynFlags setFlags body = G.gbracket setup teardown (\_ -> body)
-  where
-    setup = do
-        dflags <- G.getSessionDynFlags
-        void $ G.setSessionDynFlags (setFlags dflags)
-        return dflags
-    teardown = void . G.setSessionDynFlags
-
-withCmdFlags :: GhcMonad m => [GHCOption] -> m a -> m a
-withCmdFlags flags body = G.gbracket setup teardown (\_ -> body)
-  where
-    setup = do
-        dflags <- G.getSessionDynFlags >>= addCmdOpts flags
-        void $ G.setSessionDynFlags dflags
-        return dflags
-    teardown = void . G.setSessionDynFlags
-
----------------------------------------------------------------
-
-- | Set 'DynFlags' equivalent to "-w:".
-setNoWaringFlags :: DynFlags -> DynFlags
-setNoWaringFlags df = df { warningFlags = Gap.emptyWarnFlags}
-
-- | Set 'DynFlags' equivalent to "-Wall".
-setAllWaringFlags :: DynFlags -> DynFlags
-setAllWaringFlags df = df { warningFlags = allWarningFlags }
-
-- | Set 'DynFlags' equivalent to "-fno-max-relevant-bindings".
-setNoMaxRelevantBindings :: DynFlags -> DynFlags
-#if __GLASGOW_HASKELL__ >= 708
-setNoMaxRelevantBindings df = df { maxRelevantBinds = Nothing }
-#else
-setNoMaxRelevantBindings = id
-#endif
+findModule :: ModuleString -> PkgDb -> [Package]
+findModule m db = do
+  M.elems $ package `M.map` (containsModule `M.filter` db)
+ where
+    containsModule :: G.PackageConfig -> Bool
+    containsModule pkgConf =
+        G.mkModuleName m `elem` G.exposedModules pkgConf


-allWarningFlags :: Gap.WarnFlags
-allWarningFlags = unsafePerformIO $ do
-    mlibdir <- getSystemLibDir
-    G.runGhc mlibdir $ do
-        df <- G.getSessionDynFlags
-        df' <- addCmdOpts ["-Wall"] df
-        return $ G.warningFlags df'
+ghcPkgId :: Package -> G.PackageId
+ghcPkgId (name,_,_) =
+    -- TODO: Adding the package version too breaks 'findModule' for some reason
+    -- this isn't a big deal since in the common case where we're in a cabal
+    -- project we just use cabal's view of package dependencies anyways so we're
+    -- guaranteed to only have one version of each package exposed. However when
+    -- we're operating without a cabal project this will probaly cause trouble.
+    G.stringToPackageId name
+
+type Binding = String
+
+-- | @moduleInfo mpkg module@. @mpkg@ should be 'Nothing' iff. moduleInfo
+-- should look for @module@ in the working directory.
+--
+-- To map a 'ModuleString' to a package see 'findModule'
+moduleInfo :: GhcMonad m
+           => Maybe Package
+           -> ModuleString
+           -> m (Maybe G.ModuleInfo)
+moduleInfo mpkg mdl = do
+    let mdlName = G.mkModuleName mdl
+        mfsPkgId = G.packageIdFS . ghcPkgId <$> mpkg
+    loadLocalModule
+    G.findModule mdlName mfsPkgId >>= G.getModuleInfo
+ where
+   loadLocalModule = case mpkg of
+       Just _ -> return ()
+       Nothing -> setTargetFiles [mdl]
+
+localModuleInfo :: GhcMonad m => ModuleString -> m (Maybe G.ModuleInfo)
+localModuleInfo mdl = moduleInfo Nothing mdl
+
+bindings :: G.ModuleInfo -> [Binding]
+bindings minfo = do
+  map (G.occNameString . G.getOccName) $ G.modInfoExports minfo
--- a/Language/Haskell/GhcMod/Gap.hs
+++ b/Language/Haskell/GhcMod/Gap.hs
@@ -33,6 +33,12 @@ module Language.Haskell.GhcMod.Gap (
  , fileModSummary
  , WarnFlags
  , emptyWarnFlags
+  , benchmarkBuildInfo
+  , benchmarkTargets
+  , toModuleString
+  , GLMatch
+  , getClass
+  , occName
  ) where

 import Control.Applicative hiding (empty)
@@ -58,6 +64,7 @@ import StringBuffer
 import TcType
 import Var (varType)

+import qualified Distribution.PackageDescription as P
 import qualified InstEnv
 import qualified Pretty
 import qualified StringBuffer as SB
@@ -76,10 +83,12 @@ import GHC hiding (ClsInst)
 import GHC hiding (Instance)
 import Control.Arrow hiding ((<+>))
 import Data.Convertible
+import RdrName (rdrNameOcc)
 #endif

 #if __GLASGOW_HASKELL__ >= 704
 import qualified Data.IntSet as I (IntSet, empty)
+import qualified Distribution.ModuleName as M (ModuleName,toFilePath)
 #endif

 ----------------------------------------------------------------
@@ -280,8 +289,10 @@ class HasType a where

 instance HasType (LHsBind Id) where
 #if __GLASGOW_HASKELL__ >= 708
-    getType _ (L spn FunBind{fun_matches = MG _ in_tys out_typ}) = return $ Just (spn, typ)
-      where typ = mkFunTys in_tys out_typ
+    getType _ (L spn FunBind{fun_matches = m}) = return $ Just (spn, typ)
+      where in_tys = mg_arg_tys m
+            out_typ = mg_res_ty m
+            typ = mkFunTys in_tys out_typ
 #else
    getType _ (L spn FunBind{fun_matches = MatchGroup _ typ}) = return $ Just (spn, typ)
 #endif
@@ -396,3 +407,55 @@ type WarnFlags = [WarningFlag]
 emptyWarnFlags :: WarnFlags
 emptyWarnFlags = []
 #endif
+
+----------------------------------------------------------------
+----------------------------------------------------------------
+
+benchmarkBuildInfo :: P.PackageDescription -> [P.BuildInfo]
+#if __GLASGOW_HASKELL__ >= 704
+benchmarkBuildInfo pd = map P.benchmarkBuildInfo $ P.benchmarks pd
+#else
+benchmarkBuildInfo pd = []
+#endif
+
+benchmarkTargets :: P.PackageDescription -> [String]
+#if __GLASGOW_HASKELL__ >= 704
+benchmarkTargets pd = map toModuleString $ concatMap P.benchmarkModules $ P.benchmarks pd
+#else
+benchmarkTargets = []
+#endif
+
+toModuleString :: M.ModuleName -> String
+toModuleString mn = fromFilePath $ M.toFilePath mn
+  where
+    fromFilePath :: FilePath -> String
+    fromFilePath fp = map (\c -> if c=='/' then '.' else c) fp
+
+----------------------------------------------------------------
+----------------------------------------------------------------
+
+#if __GLASGOW_HASKELL__ >= 708
+type GLMatch = LMatch RdrName (LHsExpr RdrName)
+#else
+type GLMatch = LMatch RdrName
+#endif
+
+getClass :: [LInstDecl Name] -> Maybe (Name, SrcSpan)
+#if __GLASGOW_HASKELL__ >= 708
+-- Instance declarations of sort 'instance F (G a)'
+getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _))))}))] = Just (className, loc)
+-- Instance declarations of sort 'instance F G' (no variables)
+getClass [L loc (ClsInstD (ClsInstDecl {cid_poly_ty = (L _ (HsAppTy (L _ (HsTyVar className)) _))}))] = Just (className, loc)
+#elif __GLASGOW_HASKELL__ >= 706
+getClass [L loc (ClsInstD (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _)))) _ _ _)] = Just (className, loc)
+getClass[L loc (ClsInstD (L _ (HsAppTy (L _ (HsTyVar className)) _)) _ _ _)] = Just (className, loc)
+#else
+getClass [L loc (InstDecl (L _ (HsForAllTy _ _ _ (L _ (HsAppTy (L _ (HsTyVar className)) _)))) _ _ _)] = Just (className, loc)
+getClass [L loc (InstDecl (L _ (HsAppTy (L _ (HsTyVar className)) _)) _ _ _)] = Just (className, loc)
+#endif
+getClass _ = Nothing
+
+#if __GLASGOW_HASKELL__ < 706
+occName :: RdrName -> OccName
+occName = rdrNameOcc
+#endif
--- a/Language/Haskell/GhcMod/Ghc.hs
+++ b/Language/Haskell/GhcMod/Ghc.hs
@@ -1,31 +1,10 @@
 module Language.Haskell.GhcMod.Ghc (
-  -- * Converting the 'Ghc' monad to the 'IO' monad
-    withGHC
-  , withGHC'
-  -- * 'Ghc' utilities
-  , boot
-  , browse
-  , check
-  , info
-  , types
-  , splits
-  , sig
-  , refine
-  , modules
  -- * 'SymMdlDb'
-  , Symbol
+    Symbol
  , SymMdlDb
  , getSymMdlDb
  , lookupSym
  , lookupSym'
  ) where

-import Language.Haskell.GhcMod.Boot
-import Language.Haskell.GhcMod.Browse
-import Language.Haskell.GhcMod.Check
 import Language.Haskell.GhcMod.Find
-import Language.Haskell.GhcMod.GHCApi
-import Language.Haskell.GhcMod.Info
-import Language.Haskell.GhcMod.List
-import Language.Haskell.GhcMod.FillSig
-import Language.Haskell.GhcMod.CaseSplit
--- a/Language/Haskell/GhcMod/Info.hs
+++ b/Language/Haskell/GhcMod/Info.hs
@@ -1,7 +1,5 @@
 module Language.Haskell.GhcMod.Info (
-    infoExpr
-  , info
-  , typeExpr
+    info
  , types
  ) where

@@ -13,7 +11,6 @@ import Exception (ghandle, SomeException(..))
 import GHC (GhcMonad, LHsBind, LHsExpr, LPat, Id, TypecheckedModule(..), SrcSpan, Type)
 import qualified GHC as G
 import Language.Haskell.GhcMod.Doc (showPage)
-import Language.Haskell.GhcMod.GHCApi
 import Language.Haskell.GhcMod.Gap (HasType(..))
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Monad
@@ -24,19 +21,10 @@ import Language.Haskell.GhcMod.Convert
 ----------------------------------------------------------------

 -- | Obtaining information of a target expression. (GHCi's info:)
-infoExpr :: Options
-         -> Cradle
-         -> FilePath     -- ^ A target file.
-         -> Expression   -- ^ A Haskell expression.
-         -> IO String
-infoExpr opt cradle file expr = runGhcMod opt $ do
-    initializeFlagsWithCradle opt cradle
-    info file expr
-
-- | Obtaining information of a target expression. (GHCi's info:)
-info :: FilePath     -- ^ A target file.
+info :: IOish m
+     => FilePath     -- ^ A target file.
     -> Expression   -- ^ A Haskell expression.
-     -> GhcMod String
+     -> GhcModT m String
 info file expr = do
    opt <- options
    convert opt <$> ghandle handler body
@@ -49,21 +37,11 @@ info file expr = do
 ----------------------------------------------------------------

 -- | Obtaining type of a target expression. (GHCi's type:)
-typeExpr :: Options
-         -> Cradle
-         -> FilePath     -- ^ A target file.
-         -> Int          -- ^ Line number.
-         -> Int          -- ^ Column number.
-         -> IO String
-typeExpr opt cradle file lineNo colNo = runGhcMod opt $ do
-    initializeFlagsWithCradle opt cradle
-    types file lineNo colNo
-
-- | Obtaining type of a target expression. (GHCi's type:)
-types :: FilePath     -- ^ A target file.
+types :: IOish m
+      => FilePath     -- ^ A target file.
      -> Int          -- ^ Line number.
      -> Int          -- ^ Column number.
-      -> GhcMod String
+      -> GhcModT m String
 types file lineNo colNo = do
    opt <- options
    convert opt <$> ghandle handler body
@@ -85,4 +63,3 @@ getSrcSpanType modSum lineNo colNo = do
    ets <- mapM (getType tcm) es
    pts <- mapM (getType tcm) ps
    return $ catMaybes $ concat [ets, bts, pts]
-
--- a/Language/Haskell/GhcMod/Internal.hs
+++ b/Language/Haskell/GhcMod/Internal.hs
@@ -16,11 +16,10 @@ module Language.Haskell.GhcMod.Internal (
  , cabalDependPackages
  , cabalSourceDirs
  , cabalAllTargets
+  -- * GHC.Paths
+  , ghcLibDir
  -- * IO
-  , getSystemLibDir
  , getDynamicFlags
-  -- * Initializing 'DynFlags'
-  , initializeFlagsWithCradle
  -- * Targets
  , setTargetFiles
  -- * Logging
@@ -35,8 +34,14 @@ module Language.Haskell.GhcMod.Internal (
  , (|||>)
  ) where

+import GHC.Paths (libdir)
+
 import Language.Haskell.GhcMod.CabalApi
-import Language.Haskell.GhcMod.GHCApi
+import Language.Haskell.GhcMod.DynFlags
 import Language.Haskell.GhcMod.GHCChoice
 import Language.Haskell.GhcMod.Logger
 import Language.Haskell.GhcMod.Types
+
+-- | Obtaining the directory for ghc system libraries.
+ghcLibDir :: FilePath
+ghcLibDir = libdir
--- a/Language/Haskell/GhcMod/Lang.hs
+++ b/Language/Haskell/GhcMod/Lang.hs
@@ -1,10 +1,10 @@
 module Language.Haskell.GhcMod.Lang where

 import DynFlags (supportedLanguagesAndExtensions)
-import Language.Haskell.GhcMod.Types
 import Language.Haskell.GhcMod.Convert
+import Language.Haskell.GhcMod.Monad

 -- | Listing language extensions.

-listLanguages :: Options -> IO String
-listLanguages opt = return $ convert opt supportedLanguagesAndExtensions
+languages :: IOish m => GhcModT m String
+languages = convert' supportedLanguagesAndExtensions
--- a/Language/Haskell/GhcMod/Lint.hs
+++ b/Language/Haskell/GhcMod/Lint.hs
@@ -1,19 +1,21 @@
 module Language.Haskell.GhcMod.Lint where

-import Control.Applicative ((<$>))
-import Control.Exception (handle, SomeException(..))
+import Exception (ghandle)
+import Control.Exception (SomeException(..))
+import CoreMonad (liftIO)
 import Language.Haskell.GhcMod.Logger (checkErrorPrefix)
 import Language.Haskell.GhcMod.Convert
-import Language.Haskell.GhcMod.Types
+import Language.Haskell.GhcMod.Monad
 import Language.Haskell.HLint (hlint)

 -- | Checking syntax of a target file using hlint.
 --   Warnings and errors are returned.
-lintSyntax :: Options
-           -> FilePath  -- ^ A target file.
-           -> IO String
-lintSyntax opt file = handle handler $ pack <$> hlint (file : "--quiet" : hopts)
-  where
-    pack = convert opt . map (init . show) -- init drops the last \n.
-    hopts = hlintOpts opt
+lint :: IOish m
+     => FilePath  -- ^ A target file.
+     -> GhcModT m String
+lint file = do
+  opt <- options
+  ghandle handler . pack =<< (liftIO $ hlint $ file : "--quiet" : hlintOpts opt)
+ where
+    pack = convert' . map (init . show) -- init drops the last \n.
    handler (SomeException e) = return $ checkErrorPrefix ++ show e ++ "\n"
--- a/Language/Haskell/GhcMod/List.hs
+++ b/Language/Haskell/GhcMod/List.hs
@@ -1,4 +1,4 @@
-module Language.Haskell.GhcMod.List (listModules, modules) where
+module Language.Haskell.GhcMod.List (modules) where

 import Control.Applicative ((<$>))
 import Control.Exception (SomeException(..))
@@ -6,18 +6,13 @@ import Data.List (nub, sort)
 import qualified GHC as G
 import Language.Haskell.GhcMod.Monad
 import Language.Haskell.GhcMod.Convert
-import Language.Haskell.GhcMod.Types
 import Packages (pkgIdMap, exposedModules, sourcePackageId, display)
 import UniqFM (eltsUFM)

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

 -- | Listing installed modules.
-listModules :: Options -> Cradle -> IO String
-listModules opt _ = runGhcMod opt $ modules
-
-- | Listing installed modules.
-modules :: GhcMod String
+modules :: IOish m => GhcModT m String
 modules = do
    opt <- options
    convert opt . (arrange opt) <$> (getModules `G.gcatch` handler)
--- a/Language/Haskell/GhcMod/Logger.hs
+++ b/Language/Haskell/GhcMod/Logger.hs
@@ -6,7 +6,7 @@ module Language.Haskell.GhcMod.Logger (
  ) where

 import Bag (Bag, bagToList)
-import Control.Applicative ((<$>),(*>))
+import Control.Applicative ((<$>))
 import CoreMonad (liftIO)
 import Data.IORef (IORef, newIORef, readIORef, writeIORef, modifyIORef)
 import Data.List (isPrefixOf)
@@ -17,11 +17,10 @@ import GHC (DynFlags, SrcSpan, Severity(SevError))
 import qualified GHC as G
 import HscTypes (SourceError, srcErrorMessages)
 import Language.Haskell.GhcMod.Doc (showPage, getStyle)
-import Language.Haskell.GhcMod.GHCApi (withDynFlags, withCmdFlags)
+import Language.Haskell.GhcMod.DynFlags (withDynFlags, withCmdFlags)
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Language.Haskell.GhcMod.Convert (convert')
 import Language.Haskell.GhcMod.Monad
-import Language.Haskell.GhcMod.Types (Options(..))
 import Outputable (PprStyle, SDoc)
 import System.FilePath (normalise)

@@ -29,35 +28,46 @@ import System.FilePath (normalise)

 type Builder = [String] -> [String]

-newtype LogRef = LogRef (IORef Builder)
+data Log = Log [String] Builder
+
+newtype LogRef = LogRef (IORef Log)
+
+emptyLog :: Log
+emptyLog = Log [] id

 newLogRef :: IO LogRef
-newLogRef = LogRef <$> newIORef id
+newLogRef = LogRef <$> newIORef emptyLog

-readAndClearLogRef :: LogRef -> GhcMod String
+readAndClearLogRef :: IOish m => LogRef -> GhcModT m String
 readAndClearLogRef (LogRef ref) = do
-    b <- liftIO $ readIORef ref
-    liftIO $ writeIORef ref id
+    Log _ b <- liftIO $ readIORef ref
+    liftIO $ writeIORef ref emptyLog
    convert' (b [])

 appendLogRef :: DynFlags -> LogRef -> DynFlags -> Severity -> SrcSpan -> PprStyle -> SDoc -> IO ()
-appendLogRef df (LogRef ref) _ sev src style msg = do
-        let !l = ppMsg src sev df style msg
-        modifyIORef ref (\b -> b . (l:))
+appendLogRef df (LogRef ref) _ sev src style msg = modifyIORef ref update
+  where
+    l = ppMsg src sev df style msg
+    update lg@(Log ls b)
+      | l `elem` ls = lg
+      | otherwise   = Log (l:ls) (b . (l:))

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

 -- | Set the session flag (e.g. "-Wall" or "-w:") then
 --   executes a body. Logged messages are returned as 'String'.
 --   Right is success and Left is failure.
-withLogger :: (DynFlags -> DynFlags)
-           -> GhcMod ()
-           -> GhcMod (Either String String)
+withLogger :: IOish m
+           => (DynFlags -> DynFlags)
+           -> GhcModT m ()
+           -> GhcModT m (Either String String)
 withLogger setDF body = ghandle sourceError $ do
    logref <- liftIO $ newLogRef
    wflags <- filter ("-fno-warn" `isPrefixOf`) . ghcOpts <$> options
    withDynFlags (setLogger logref . setDF) $ do
-        withCmdFlags wflags $ do body *> (Right <$> readAndClearLogRef logref)
+        withCmdFlags wflags $ do
+            body
+            Right <$> readAndClearLogRef logref
  where
    setLogger logref df = Gap.setLogAction df $ appendLogRef df logref

@@ -65,7 +75,7 @@ withLogger setDF body = ghandle sourceError $ do
 ----------------------------------------------------------------

 -- | Converting 'SourceError' to 'String'.
-sourceError :: SourceError -> GhcMod (Either String String)
+sourceError :: IOish m => SourceError -> GhcModT m (Either String String)
 sourceError err = do
    dflags <- G.getSessionDynFlags
    style <- toGhcMod getStyle
--- a/Language/Haskell/GhcMod/Monad.hs
+++ b/Language/Haskell/GhcMod/Monad.hs
@@ -1,29 +1,54 @@
 {-# LANGUAGE CPP, GeneralizedNewtypeDeriving, FlexibleInstances #-}
-{-# LANGUAGE MultiParamTypeClasses, RankNTypes, TypeFamilies #-}
+{-# LANGUAGE FlexibleContexts, MultiParamTypeClasses, RankNTypes #-}
+{-# LANGUAGE TypeFamilies, UndecidableInstances, RecordWildCards #-}
+{-# LANGUAGE StandaloneDeriving #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}

 module Language.Haskell.GhcMod.Monad (
   GhcMod
+ , runGhcMod
+ , liftGhcMod
+ , GhcModT
+ , IOish
 , GhcModEnv(..)
 , GhcModWriter
 , GhcModState(..)
- , runGhcMod'
- , runGhcMod
+ , runGhcModT'
+ , runGhcModT
+ , newGhcModEnv
 , withErrorHandler
 , toGhcMod
 , options
+ , cradle
+ , Options(..)
+ , defaultOptions
 , module Control.Monad.Reader.Class
 , module Control.Monad.Writer.Class
 , module Control.Monad.State.Class
 ) where

-import Language.Haskell.GhcMod.Cradle
-import Language.Haskell.GhcMod.GHCApi
+#if __GLASGOW_HASKELL__ < 708
+-- 'CoreMonad.MonadIO' and 'Control.Monad.IO.Class.MonadIO' are different
+-- classes before ghc 7.8
+#define DIFFERENT_MONADIO 1
+
+-- RWST doen't have a MonadIO instance before ghc 7.8
+#define MONADIO_INSTANCES 1
+#endif
+
+
 import Language.Haskell.GhcMod.Types
+import Language.Haskell.GhcMod.Cradle
+import Language.Haskell.GhcMod.DynFlags
+import Language.Haskell.GhcMod.GhcPkg
+import Language.Haskell.GhcMod.GHCChoice
+import Language.Haskell.GhcMod.CabalApi
+import qualified Language.Haskell.GhcMod.Gap as Gap

 import DynFlags
 import Exception
 import GHC
+import qualified GHC as G
 import GHC.Paths (libdir)
 import GhcMonad
 #if __GLASGOW_HASKELL__ <= 702
@@ -36,23 +61,33 @@ import HscTypes
 -- So, RWST automatically becomes an instance of MonadIO.
 import MonadUtils

-#if __GLASGOW_HASKELL__ < 708
-- To make RWST an instance of MonadIO.
+#if DIFFERENT_MONADIO
 import Control.Monad.Trans.Class (lift)
+import qualified Control.Monad.IO.Class
 import Data.Monoid (Monoid)
 #endif

-import Control.Monad (liftM)
-import Control.Monad.Base (MonadBase,liftBase)
+import Control.Applicative (Alternative)
+import Control.Monad (MonadPlus, liftM, void)
+import Control.Monad.Base (MonadBase, liftBase)
+
 import Control.Monad.Reader.Class
 import Control.Monad.State.Class
-import Control.Monad.Trans.Control (MonadBaseControl(..), StM, liftBaseWith, control, liftBaseOp, liftBaseOp_)
-import Control.Monad.Trans.RWS.Lazy (RWST(..),runRWST)
+import Control.Monad.Trans.Class
+#if __GLASGOW_HASKELL__ < 708
+import Control.Monad.Trans.Maybe
+#endif
+import Control.Monad.Trans.Control (MonadBaseControl(..), StM, liftBaseWith,
+  control, liftBaseOp, liftBaseOp_)
+import Control.Monad.Trans.RWS.Lazy (RWST(..), runRWST)
 import Control.Monad.Writer.Class
+import Control.Monad.Error (Error(..), ErrorT(..), MonadError)

+import Data.Maybe (fromJust, isJust)
 import Data.IORef (IORef, readIORef, writeIORef, newIORef)
 import System.Exit (exitSuccess)
 import System.IO (hPutStr, hPrint, stderr)
+import System.Directory (getCurrentDirectory)

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

@@ -62,102 +97,268 @@ data GhcModEnv = GhcModEnv {
    , gmCradle     :: Cradle
    }

-data GhcModState = GhcModState
+data GhcModState = GhcModState deriving (Eq,Show,Read)

 defaultState :: GhcModState
 defaultState = GhcModState

 type GhcModWriter = ()

+data GhcModError = GMENoMsg
+                 | GMEString String
+                 | GMECabal
+                 | GMEGhc
+                   deriving (Eq,Show,Read)
+
+instance Error GhcModError where
+    noMsg = GMENoMsg
+    strMsg = GMEString
+
 ----------------------------------------------------------------

-newtype GhcMod a = GhcMod {
-      unGhcMod :: RWST GhcModEnv GhcModWriter GhcModState IO a
+type IOish m = (Functor m, MonadIO m, MonadBaseControl IO m)
+
+type GhcMod a = GhcModT (ErrorT GhcModError IO) a
+
+newtype GhcModT m a = GhcModT {
+      unGhcModT :: RWST GhcModEnv GhcModWriter GhcModState m a
    } deriving (Functor
-               ,Applicative
-               ,Monad
-               ,MonadIO
-               ,MonadReader GhcModEnv
-               ,MonadWriter GhcModWriter
-               ,MonadState GhcModState
+               , Applicative
+               , Alternative
+               , Monad
+               , MonadPlus
+               , MonadIO
+#if DIFFERENT_MONADIO
+               , Control.Monad.IO.Class.MonadIO
+#endif
+               , MonadReader GhcModEnv
+               , MonadWriter GhcModWriter
+               , MonadState GhcModState
+               , MonadTrans
               )

-#if __GLASGOW_HASKELL__ < 708
+deriving instance MonadError GhcModError m => MonadError GhcModError (GhcModT m)
+
+#if MONADIO_INSTANCES
 instance (Monoid w, MonadIO m) => MonadIO (RWST r w s m) where
--  liftIO :: MonadIO m => IO a -> m a
    liftIO = lift . liftIO
+
+instance (Error e, MonadIO m) => MonadIO (ErrorT e m) where
+    liftIO = lift . liftIO
+
+instance (MonadIO m) => MonadIO (MaybeT m) where
+    liftIO = lift . liftIO
+
 #endif

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

-runGhcMod' :: GhcModEnv
-          -> GhcModState
-          -> GhcMod a
-          -> IO (a,(GhcModState, GhcModWriter))
-runGhcMod' r s a = do
-  (a', s',w) <- runRWST (unGhcMod $ initGhcMonad (Just libdir) >> a) r s
-  return (a',(s',w))
+-- | Initialize the 'DynFlags' relating to the compilation of a single
+-- file or GHC session according to the 'Cradle' and 'Options'
+-- provided.
+initializeFlagsWithCradle :: GhcMonad m
+        => Options
+        -> Cradle
+        -> m ()
+initializeFlagsWithCradle opt c
+  | cabal     = withCabal |||> withSandbox
+  | otherwise = withSandbox
+  where
+    mCradleFile = cradleCabalFile c
+    cabal = isJust mCradleFile
+    ghcopts = ghcOpts opt
+    withCabal = do
+        pkgDesc <- liftIO $ parseCabalFile $ fromJust mCradleFile
+        compOpts <- liftIO $ getCompilerOptions ghcopts c pkgDesc
+        initSession CabalPkg opt compOpts
+    withSandbox = initSession SingleFile opt compOpts
+      where
+        importDirs = [".","..","../..","../../..","../../../..","../../../../.."]
+        pkgOpts = ghcDbStackOpts $ cradlePkgDbStack c
+        compOpts
+          | null pkgOpts = CompilerOptions ghcopts importDirs []
+          | otherwise    = CompilerOptions (ghcopts ++ pkgOpts) [wdir,rdir] []
+        wdir = cradleCurrentDir c
+        rdir = cradleRootDir    c

-
-runGhcMod :: Options -> GhcMod a -> IO a
-runGhcMod opt action = do
-    session <- newIORef (error "empty session")
-    cradle <- findCradle
-    let env = GhcModEnv { gmGhcSession = session
-                        , gmOptions = opt
-                        , gmCradle = cradle }
-    (a,(_,_)) <- runGhcMod' env defaultState $ do
-        dflags <- getSessionDynFlags
-        defaultCleanupHandler dflags $ do
-            toGhcMod $ initializeFlagsWithCradle opt cradle
-            action
-    return a
+initSession :: GhcMonad m
+            => Build
+            -> Options
+            -> CompilerOptions
+            -> m ()
+initSession build Options {..} CompilerOptions {..} = do
+    df <- G.getSessionDynFlags
+    void $ G.setSessionDynFlags =<< (addCmdOpts ghcOptions
+      $ setModeSimple
+      $ setIncludeDirs includeDirs
+      $ setBuildEnv build
+      $ setEmptyLogger
+      $ Gap.addPackageFlags depPackages df)

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

-withErrorHandler :: String -> GhcMod a -> GhcMod a
+newGhcModEnv :: Options -> FilePath -> IO GhcModEnv
+newGhcModEnv opt dir = do
+      session <- newIORef (error "empty session")
+      c <- findCradle' dir
+      return GhcModEnv {
+          gmGhcSession = session
+        , gmOptions = opt
+        , gmCradle = c
+        }
+
+-- | Run a @GhcModT m@ computation, i.e. one with a custom underlying monad.
+--
+-- You probably don't want this, look at 'runGhcMod' instead.
+runGhcModT :: IOish m => Options -> GhcModT m a -> m a
+runGhcModT opt action = do
+    env <- liftBase $ newGhcModEnv opt =<< getCurrentDirectory
+    (a,(_,_)) <- runGhcModT' env defaultState $ do
+        dflags <- getSessionDynFlags
+        defaultCleanupHandler dflags $ do
+            initializeFlagsWithCradle opt (gmCradle env)
+            action
+    return a
+
+-- | Run a computation inside @GhcModT@ providing the RWST environment and
+-- initial state. This is a low level function, use it only if you know what to
+-- do with 'GhcModEnv' and 'GhcModState'.
+--
+-- You should probably look at 'runGhcModT' instead.
+runGhcModT' :: IOish m
+           => GhcModEnv
+           -> GhcModState
+           -> GhcModT m a
+           -> m (a,(GhcModState, GhcModWriter))
+runGhcModT' r s a = do
+  (a',s',w) <- runRWST (unGhcModT $ initGhcMonad (Just libdir) >> a) r s
+  return (a',(s',w))
+
+-- | Run a 'GhcMod' computation. If you want an underlying monad other than
+-- 'ErrorT e IO' you should look at 'runGhcModT'
+runGhcMod :: Options
+          -> GhcMod a
+          -> IO (Either GhcModError a)
+runGhcMod o a =
+  runErrorT $ runGhcModT o a
+
+liftErrorT :: IOish m => GhcModT m a -> GhcModT (ErrorT GhcModError m) a
+liftErrorT action =
+    GhcModT $ RWST $ \e s -> ErrorT $ Right <$> (runRWST $ unGhcModT action) e s
+
+-- | Lift @(GhcModT IO)@ into @GhcMod@, which is an alias for @GhcModT (ErrorT
+-- GhcModError IO)@.
+liftGhcMod :: GhcModT IO a -> GhcMod a
+liftGhcMod = liftErrorT
+
+----------------------------------------------------------------
+
+withErrorHandler :: IOish m => String -> GhcModT m a -> GhcModT m a
 withErrorHandler label = ghandle ignore
  where
-    ignore :: SomeException -> GhcMod a
+    ignore :: IOish m => SomeException -> GhcModT m a
    ignore e = liftIO $ do
        hPutStr stderr $ label ++ ":0:0:Error:"
        hPrint stderr e
        exitSuccess

-toGhcMod :: Ghc a -> GhcMod a
+-- | This is only a transitional mechanism don't use it for new code.
+toGhcMod :: IOish m => Ghc a -> GhcModT m a
 toGhcMod a = do
    s <- gmGhcSession <$> ask
    liftIO $ unGhc a $ Session s

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

-options :: GhcMod Options
+options :: IOish m => GhcModT m Options
 options = gmOptions <$> ask

-instance MonadBase IO GhcMod where
-    liftBase = GhcMod . liftBase
+cradle :: IOish m => GhcModT m Cradle
+cradle = gmCradle <$> ask

-instance MonadBaseControl IO GhcMod where
-    newtype StM GhcMod a = StGhcMod {
-          unStGhcMod :: StM (RWST GhcModEnv () GhcModState IO) a }
+instance (MonadBaseControl IO m) => MonadBase IO (GhcModT m) where
+    liftBase = GhcModT . liftBase

-    liftBaseWith f = GhcMod . liftBaseWith $ \runInBase ->
-        f $ liftM StGhcMod . runInBase . unGhcMod
+instance (MonadBaseControl IO m) => MonadBaseControl IO (GhcModT m) where
+    newtype StM (GhcModT m) a = StGhcMod {
+          unStGhcMod :: StM (RWST GhcModEnv GhcModWriter GhcModState m) a }

-    restoreM = GhcMod . restoreM . unStGhcMod
+    liftBaseWith f = GhcModT . liftBaseWith $ \runInBase ->
+        f $ liftM StGhcMod . runInBase . unGhcModT
+
+    restoreM = GhcModT . restoreM . unStGhcMod
    {-# INLINE liftBaseWith #-}
    {-# INLINE restoreM #-}

-instance GhcMonad GhcMod where
-    getSession = liftIO . readIORef . gmGhcSession =<< ask
-    setSession a = liftIO . flip writeIORef a . gmGhcSession =<< ask
+-- GHC cannot prove the following instances to be decidable automatically using
+-- the FlexibleContexts extension as they violate the second Paterson Condition,
+-- namely that: The assertion has fewer constructors and variables (taken
+-- together and counting repetitions) than the head. Specifically the
+-- @MonadBaseControl IO m@ constraint is causing this violation.
+--
+-- Proof of termination:
+--
+-- Assuming all constraints containing the variable `m' exist and are decidable
+-- we show termination by manually replacing the current set of constraints with
+-- their own set of constraints and show that this, after a finite number of
+-- steps, results in the empty set, i.e. not having to check any more
+-- constraints.
+--
+-- We start by setting the constraints to be those immediate constraints of the
+-- instance declaration which cannot be proven decidable automatically for the
+-- type under consideration.
+--
+-- @
+-- { MonadBaseControl IO m }
+-- @
+--
+-- Classes used:
+--
+-- * @class MonadBase b m => MonadBaseControl b m@
+--
+-- @
+-- { MonadBase IO m }
+-- @
+--
+-- Classes used:
+--
+-- * @class (Applicative b, Applicative m, Monad b, Monad m) => MonadBase b m@
+--
+-- @
+-- { Applicative IO, Applicative m, Monad IO, Monad m }
+-- @
+--
+-- Classes used:
+--
+-- * @class Monad m@
+-- * @class Applicative f => Functor f@
+--
+-- @
+-- { Functor m }
+-- @
+--
+-- Classes used:
+--
+-- * @class Functor f@
+--
+-- @
+-- { }
+-- @
+-- ∎
+
+instance (Functor m, MonadIO m, MonadBaseControl IO m)
+      => GhcMonad (GhcModT m) where
+    getSession = (liftIO . readIORef) . gmGhcSession =<< ask
+    setSession a = (liftIO . flip writeIORef a) . gmGhcSession =<< ask

 #if __GLASGOW_HASKELL__ >= 706
-instance HasDynFlags GhcMod where
+instance (Functor m, MonadIO m, MonadBaseControl IO m)
+      => HasDynFlags (GhcModT m) where
    getDynFlags = getSessionDynFlags
 #endif

-instance ExceptionMonad GhcMod where
+instance (MonadIO m, MonadBaseControl IO m)
+      => ExceptionMonad (GhcModT m) where
    gcatch act handler = control $ \run ->
        run act `gcatch` (run . handler)

--- a/Language/Haskell/GhcMod/PkgDoc.hs
+++ b/Language/Haskell/GhcMod/PkgDoc.hs
@@ -1,30 +1,26 @@
-module Language.Haskell.GhcMod.PkgDoc (packageDoc) where
+module Language.Haskell.GhcMod.PkgDoc (pkgDoc) where

+import CoreMonad (liftIO)
 import Language.Haskell.GhcMod.Types
 import Language.Haskell.GhcMod.GhcPkg
+import Language.Haskell.GhcMod.Monad

 import Control.Applicative ((<$>))
 import System.Process (readProcess)

 -- | Obtaining the package name and the doc path of a module.
-packageDoc :: Options
-           -> Cradle
-           -> ModuleString
-           -> IO String
-packageDoc _ cradle mdl = pkgDoc cradle mdl
-
-pkgDoc :: Cradle -> String -> IO String
-pkgDoc cradle mdl = do
-    pkg <- trim <$> readProcess "ghc-pkg" toModuleOpts []
+pkgDoc :: IOish m => String -> GhcModT m String
+pkgDoc mdl = cradle >>= \c -> liftIO $ do
+    pkg <- trim <$> readProcess "ghc-pkg" (toModuleOpts c) []
    if pkg == "" then
        return "\n"
      else do
-        htmlpath <- readProcess "ghc-pkg" (toDocDirOpts pkg) []
+        htmlpath <- readProcess "ghc-pkg" (toDocDirOpts pkg c) []
        let ret = pkg ++ " " ++ drop 14 htmlpath
        return ret
  where
-    toModuleOpts = ["find-module", mdl, "--simple-output"]
-                   ++ ghcPkgDbStackOpts (cradlePkgDbStack cradle)
-    toDocDirOpts pkg = ["field", pkg, "haddock-html"]
-                       ++ ghcPkgDbStackOpts (cradlePkgDbStack cradle)
+    toModuleOpts c = ["find-module", mdl, "--simple-output"]
+                   ++ ghcPkgDbStackOpts (cradlePkgDbStack c)
+    toDocDirOpts pkg c = ["field", pkg, "haddock-html"]
+                       ++ ghcPkgDbStackOpts (cradlePkgDbStack c)
    trim = takeWhile (`notElem` " \n")
--- a/Language/Haskell/GhcMod/SrcUtils.hs
+++ b/Language/Haskell/GhcMod/SrcUtils.hs
@@ -13,7 +13,7 @@ import GhcMonad
 import qualified GHC as G
 import GHC.SYB.Utils (Stage(..), everythingStaged)
 import Language.Haskell.GhcMod.Doc (showOneLine, getStyle)
-import Language.Haskell.GhcMod.GHCApi
+import Language.Haskell.GhcMod.DynFlags
 import Language.Haskell.GhcMod.Gap (HasType(..), setWarnTypedHoles, setDeferTypeErrors)
 import qualified Language.Haskell.GhcMod.Gap as Gap
 import Outputable (PprStyle)
--- a/Language/Haskell/GhcMod/Types.hs
+++ b/Language/Haskell/GhcMod/Types.hs
@@ -1,6 +1,9 @@
 module Language.Haskell.GhcMod.Types where

 import Data.List (intercalate)
+import qualified Data.Map as M
+
+import PackageConfig (PackageConfig)

 -- | Output style.
 data OutputStyle = LispStyle  -- ^ S expression style.
@@ -87,12 +90,18 @@ showPkg (n,v,_) = intercalate "-" [n,v]
 showPkgId :: Package -> String
 showPkgId (n,v,i) = intercalate "-" [n,v,i]

+-- | Collection of packages
+type PkgDb = (M.Map Package PackageConfig)
+
 -- | Haskell expression.
 type Expression = String

 -- | Module name.
 type ModuleString = String

+-- | A Module
+type Module = [String]
+
 -- | Option information for GHC
 data CompilerOptions = CompilerOptions {
    ghcOptions  :: [GHCOption]  -- ^ Command line options