Constant-fold `__GLASGOW_HASKELL__` CPP conditionals

Now that HUGS and NHC specific code has been removed, this commit "folds"
the now redundant `#if((n)def)`s containing `__GLASGOW_HASKELL__`.  This
renders `base` officially GHC only.

This commit also removes redundant `{-# LANGUAGE CPP #-}`.
Signed-off-by: Herbert Valerio Riedel <hvr@gnu.org>

libraries/base/Control/Applicative.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -59,9 +58,7 @@ import Data.Proxy
 import Text.ParserCombinators.ReadP (ReadP)
 import Text.ParserCombinators.ReadPrec (ReadPrec)
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Conc (STM, retry, orElse)
-#endif
 
 infixl 3 <|>
 infixl 4 <*>, <*, *>, <**>
@@ -181,7 +178,6 @@ instance Applicative (Lazy.ST s) where
     pure = return
     (<*>) = ap
 
-#ifdef __GLASGOW_HASKELL__
 instance Applicative STM where
     pure = return
     (<*>) = ap
@@ -189,7 +185,6 @@ instance Applicative STM where
 instance Alternative STM where
     empty = retry
     (<|>) = orElse
-#endif
 
 instance Applicative ((->) a) where
     pure = const

libraries/base/Control/Category.hs

@@ -20,10 +20,7 @@
 module Control.Category where
 
 import qualified Prelude
-
-#ifdef __GLASGOW_HASKELL__
 import Data.Type.Equality
-#endif
 
 infixr 9 .
 infixr 1 >>>, <<<
@@ -50,11 +47,9 @@ instance Category (->) where
     id = Prelude.id
     (.) = (Prelude..)
 
-#ifdef __GLASGOW_HASKELL__
 instance Category (:=:) where
   id          = Refl
   Refl . Refl = Refl
-#endif
 
 -- | Right-to-left composition
 (<<<) :: Category cat => cat b c -> cat a b -> cat a c

libraries/base/Control/Concurrent.hs

@@ -33,17 +33,13 @@ module Control.Concurrent (
         -- * Basic concurrency operations
 
         ThreadId,
-#ifdef __GLASGOW_HASKELL__
         myThreadId,
-#endif
 
         forkIO,
-#ifdef __GLASGOW_HASKELL__
         forkFinally,
         forkIOWithUnmask,
         killThread,
         throwTo,
-#endif
 
         -- ** Threads with affinity
         forkOn,
@@ -61,14 +57,12 @@ module Control.Concurrent (
 
         -- $blocking
 
-#ifdef __GLASGOW_HASKELL__
         -- ** Waiting
         threadDelay,
         threadWaitRead,
         threadWaitWrite,
         threadWaitReadSTM,
         threadWaitWriteSTM,
-#endif
 
         -- * Communication abstractions
 
@@ -77,7 +71,6 @@ module Control.Concurrent (
         module Control.Concurrent.QSem,
         module Control.Concurrent.QSemN,
 
-#ifdef __GLASGOW_HASKELL__
         -- * Bound Threads
         -- $boundthreads
         rtsSupportsBoundThreads,
@@ -85,7 +78,6 @@ module Control.Concurrent (
         isCurrentThreadBound,
         runInBoundThread,
         runInUnboundThread,
-#endif
 
         -- * Weak references to ThreadIds
         mkWeakThreadId,
@@ -117,7 +109,6 @@ import Prelude
 
 import Control.Exception.Base as Exception
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Exception
 import GHC.Conc hiding (threadWaitRead, threadWaitWrite,
                         threadWaitReadSTM, threadWaitWriteSTM)
@@ -136,7 +127,6 @@ import Foreign.C
 import System.IO
 import Data.Maybe (Maybe(..))
 #endif
-#endif
 
 import Control.Concurrent.MVar
 import Control.Concurrent.Chan
@@ -211,7 +201,6 @@ forkFinally action and_then =
   mask $ \restore ->
     forkIO $ try (restore action) >>= and_then
 
-#ifdef __GLASGOW_HASKELL__
 -- ---------------------------------------------------------------------------
 -- Bound Threads
 
@@ -396,9 +385,7 @@ runInUnboundThread action = do
 
 unsafeResult :: Either SomeException a -> IO a
 unsafeResult = either Exception.throwIO return
-#endif /* __GLASGOW_HASKELL__ */
 
-#ifdef __GLASGOW_HASKELL__
 -- ---------------------------------------------------------------------------
 -- threadWaitRead/threadWaitWrite
 
@@ -672,5 +659,3 @@ alternative then it is possible to prevent the thread from being
 considered deadlocked by making a 'StablePtr' pointing to it.  Don't
 forget to release the 'StablePtr' later with 'freeStablePtr'.
 -}
-
-#endif /* __GLASGOW_HASKELL__ */

libraries/base/Control/Concurrent/Chan.hs

 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 -----------------------------------------------------------------------------
 -- |

libraries/base/Control/Concurrent/MVar.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, UnboxedTuples, MagicHash #-}
+{-# LANGUAGE NoImplicitPrelude, UnboxedTuples, MagicHash #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -146,20 +146,13 @@ module Control.Concurrent.MVar
         , addMVarFinalizer
     ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.MVar ( MVar(..), newEmptyMVar, newMVar, takeMVar, putMVar,
                   tryTakeMVar, tryPutMVar, isEmptyMVar, readMVar,
                   tryReadMVar
                 )
 import qualified GHC.MVar
 import GHC.Weak
-#endif
-
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
-#else
-import Prelude
-#endif
 
 import Control.Exception.Base
 

libraries/base/Control/Concurrent/QSem.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
-#endif
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Concurrent/QSemN.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, BangPatterns #-}
-#endif
 {-# OPTIONS_GHC -funbox-strict-fields #-}
 
 -----------------------------------------------------------------------------

libraries/base/Control/Exception.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude, ExistentialQuantification #-}
+{-# LANGUAGE NoImplicitPrelude, ExistentialQuantification #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -44,11 +44,8 @@ module Control.Exception (
         AsyncException(..),     -- instance Eq, Ord, Show, Typeable, Exception
         asyncExceptionToException, asyncExceptionFromException,
 
-#if __GLASGOW_HASKELL__
         NonTermination(..),
         NestedAtomically(..),
-#endif
-
         BlockedIndefinitelyOnMVar(..),
         BlockedIndefinitelyOnSTM(..),
         Deadlock(..),
@@ -63,9 +60,7 @@ module Control.Exception (
         throw,
         throwIO,
         ioError,
-#ifdef __GLASGOW_HASKELL__
         throwTo,
-#endif
 
         -- * Catching Exceptions
 
@@ -136,13 +131,9 @@ module Control.Exception (
 
 import Control.Exception.Base
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO (unsafeUnmask)
 import Data.Maybe
-#else
-import Prelude hiding (catch)
-#endif
 
 -- | You need this when using 'catches'.
 data Handler a = forall e . Exception e => Handler (e -> IO a)

libraries/base/Control/Exception/Base.hs

 {-# LANGUAGE Trustworthy #-}
 {-# LANGUAGE CPP, NoImplicitPrelude, MagicHash #-}
-#ifdef __GLASGOW_HASKELL__
 {-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
-#endif
 
 #include "Typeable.h"
 
@@ -31,12 +29,8 @@ module Control.Exception.Base (
         AssertionFailed(..),
         SomeAsyncException(..), AsyncException(..),
         asyncExceptionToException, asyncExceptionFromException,
-
-#ifdef __GLASGOW_HASKELL__
         NonTermination(..),
         NestedAtomically(..),
-#endif
-
         BlockedIndefinitelyOnMVar(..),
         BlockedIndefinitelyOnSTM(..),
         Deadlock(..),
@@ -51,9 +45,7 @@ module Control.Exception.Base (
         throwIO,
         throw,
         ioError,
-#ifdef __GLASGOW_HASKELL__
         throwTo,
-#endif
 
         -- * Catching Exceptions
 
@@ -98,16 +90,13 @@ module Control.Exception.Base (
 
         finally,
 
-#ifdef __GLASGOW_HASKELL__
         -- * Calls for GHC runtime
         recSelError, recConError, irrefutPatError, runtimeError,
         nonExhaustiveGuardsError, patError, noMethodBindingError,
         absentError,
         nonTermination, nestedAtomically,
-#endif
   ) where
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.Base
 import GHC.IO hiding (bracket,finally,onException)
 import GHC.IO.Exception
@@ -115,7 +104,6 @@ import GHC.Exception
 import GHC.Show
 -- import GHC.Exception hiding ( Exception )
 import GHC.Conc.Sync
-#endif
 
 import Data.Dynamic
 import Data.Either
@@ -161,9 +149,7 @@ catch   :: Exception e
         => IO a         -- ^ The computation to run
         -> (e -> IO a)  -- ^ Handler to invoke if an exception is raised
         -> IO a
-#if __GLASGOW_HASKELL__
 catch = catchException
-#endif
 
 -- | The function 'catchJust' is like 'catch', but it takes an extra
 -- argument which is an /exception predicate/, a function which
@@ -309,15 +295,8 @@ bracketOnError before after thing =
     a <- before
     restore (thing a) `onException` after a
 
-#if !__GLASGOW_HASKELL__
-assert :: Bool -> a -> a
-assert True x = x
-assert False _ = throw (AssertionFailed "")
-#endif
-
 -----
 
-#if __GLASGOW_HASKELL__
 -- |A pattern match failed. The @String@ gives information about the
 -- source location of the pattern.
 data PatternMatchFail = PatternMatchFail String
@@ -412,9 +391,6 @@ instance Exception NestedAtomically
 
 -----
 
-#endif /* __GLASGOW_HASKELL__ */
-
-#ifdef __GLASGOW_HASKELL__
 recSelError, recConError, irrefutPatError, runtimeError,
   nonExhaustiveGuardsError, patError, noMethodBindingError,
   absentError
@@ -438,4 +414,3 @@ nonTermination = toException NonTermination
 -- GHC's RTS calls this
 nestedAtomically :: SomeException
 nestedAtomically = toException NestedAtomically
-#endif

libraries/base/Control/Monad.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP, NoImplicitPrelude #-}
+{-# LANGUAGE NoImplicitPrelude #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -78,12 +78,9 @@ module Control.Monad
 
 import Data.Maybe
 
-#ifdef __GLASGOW_HASKELL__
 import GHC.List
 import GHC.Base
-#endif
 
-#ifdef __GLASGOW_HASKELL__
 infixr 1 =<<
 
 -- -----------------------------------------------------------------------------
@@ -118,8 +115,6 @@ mapM_           :: Monad m => (a -> m b) -> [a] -> m ()
 {-# INLINE mapM_ #-}
 mapM_ f as      =  sequence_ (map f as)
 
-#endif  /* __GLASGOW_HASKELL__ */
-
 -- -----------------------------------------------------------------------------
 -- The MonadPlus class definition
 

libraries/base/Control/Monad/Fix.hs

 {-# LANGUAGE Trustworthy #-}
-{-# LANGUAGE CPP #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -26,9 +25,7 @@ module Control.Monad.Fix (
 import Prelude
 import System.IO
 import Data.Function (fix)
-#if defined(__GLASGOW_HASKELL__)
 import GHC.ST
-#endif
 
 -- | Monads having fixed points with a \'knot-tying\' semantics.
 -- Instances of 'MonadFix' should satisfy the following laws:
@@ -78,8 +75,5 @@ instance MonadFix (Either e) where
              where unRight (Right x) = x
                    unRight (Left  _) = error "mfix Either: Left"