Refactoring to use cabal-helper-wrapper

This turned out to be quite involved but save for this huge commit it's
actually quite awesome and squashes quite a few bugs and nasty
problems (hopefully). Most importantly we now have native cabal
component support without the user having to do anything to get it!

To do this we traverse imports starting from each component's
entrypoints (library modules or Main source file for executables) and
use this information to find which component's options each module will
build with. Under the assumption that these modules have to build with
every component they're used in we can now just pick one.

Quite a few internal assumptions have been invalidated by this
change. Most importantly the runGhcModT* family of cuntions now change
the current working directory to `cradleRootDir`.

Language/Haskell/GhcMod/World.hs

@@ -1,82 +1,44 @@
-{-# LANGUAGE RecordWildCards, CPP #-}
 module Language.Haskell.GhcMod.World where
-{-(
-  , World
-  , getCurrentWorld
-  , isWorldChanged
-  ) where
--}
 
 import Language.Haskell.GhcMod.GhcPkg
 import Language.Haskell.GhcMod.PathsAndFiles
 import Language.Haskell.GhcMod.Types
 import Language.Haskell.GhcMod.Utils
 
-import Control.Applicative (pure, (<$>), (<*>))
-import Control.Monad
+import Control.Applicative ((<$>))
 import Data.Maybe
 import Data.Traversable (traverse)
-import System.Directory (getModificationTime)
 import System.FilePath ((</>))
 
 import GHC.Paths (libdir)
 
-#if __GLASGOW_HASKELL__ <= 704
-import System.Time (ClockTime)
-#else
-import Data.Time (UTCTime)
-#endif
-
-
-#if __GLASGOW_HASKELL__ <= 704
-type ModTime = ClockTime
-#else
-type ModTime = UTCTime
-#endif
-
-data TimedFile = TimedFile FilePath ModTime deriving (Eq, Show)
-
-instance Ord TimedFile where
-    compare (TimedFile _ a) (TimedFile _ b) = compare a b
-
-timeFile :: FilePath -> IO TimedFile
-timeFile f = TimedFile <$> pure f <*> getModificationTime f
-
 data World = World {
     worldPackageCaches :: [TimedFile]
   , worldCabalFile     :: Maybe TimedFile
   , worldCabalConfig   :: Maybe TimedFile
   , worldSymbolCache   :: Maybe TimedFile
-  , worldPrettyCabalConfigCache :: Maybe TimedFile
   } deriving (Eq, Show)
 
-timedPackageCache :: Cradle -> IO [TimedFile]
-timedPackageCache crdl = do
+timedPackageCaches :: Cradle -> IO [TimedFile]
+timedPackageCaches crdl = do
     fs <- mapM mightExist . map (</> packageCache)
             =<< getPackageCachePaths libdir crdl
     timeFile `mapM` catMaybes fs
 
 getCurrentWorld :: Cradle -> IO World
 getCurrentWorld crdl = do
-    pkgCaches    <- timedPackageCache crdl
+    pkgCaches    <- timedPackageCaches crdl
     mCabalFile   <- timeFile `traverse` cradleCabalFile crdl
     mCabalConfig <- timeMaybe (setupConfigFile crdl)
     mSymbolCache <- timeMaybe (symbolCache crdl)
-    mPrettyConfigCache <- timeMaybe prettyConfigCache
 
     return World {
         worldPackageCaches = pkgCaches
       , worldCabalFile     = mCabalFile
       , worldCabalConfig   = mCabalConfig
       , worldSymbolCache   = mSymbolCache
-      , worldPrettyCabalConfigCache = mPrettyConfigCache
       }
 
- where
-   timeMaybe :: FilePath -> IO (Maybe TimedFile)
-   timeMaybe f = do
-     join $ (timeFile `traverse`) <$> mightExist f
-
 didWorldChange :: World -> Cradle -> IO Bool
 didWorldChange world crdl = do
     (world /=) <$> getCurrentWorld crdl