Use explicit imports

Author: agustinmista

src/Test/Mutagen/Lazy.hs

@@ -10,13 +10,11 @@ module Test.Mutagen.Lazy
   )
 where
 
-import Data.IORef
--- For providing some default Lazy instances
-
+import Data.IORef (IORef, modifyIORef', newIORef, readIORef)
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Word
-import System.IO.Unsafe
+import Data.Word (Word16, Word32, Word64, Word8)
+import System.IO.Unsafe (unsafePerformIO)
 import Test.Mutagen.Mutation (Pos)
 
 {-------------------------------------------------------------------------------

src/Test/Mutagen/Mutant.hs

@@ -10,10 +10,10 @@ module Test.Mutagen.Mutant
   )
 where
 
-import Control.Monad
-import Data.Typeable
-import Test.Mutagen.Fragment
-import Test.QuickCheck
+import Control.Monad (replicateM)
+import Data.Typeable (Typeable)
+import Test.Mutagen.Fragment (FragmentStore)
+import Test.QuickCheck (Gen, generate, resize)
 
 {-------------------------------------------------------------------------------
 -- * Abstract test case mutants

src/Test/Mutagen/Mutation.hs

@@ -26,17 +26,16 @@ module Test.Mutagen.Mutation
   )
 where
 
--- For providing some default Mutable instances
-import Data.Char
+import Data.Char (chr)
 import qualified Data.List as List
 import Data.Map (Map)
 import qualified Data.Map as Map
-import Data.Tree
-import Data.Typeable
-import Data.Word
-import Test.Mutagen.Fragment
-import Test.Mutagen.Mutant
-import Test.QuickCheck
+import Data.Tree (Tree (..), levels)
+import Data.Typeable (Typeable)
+import Data.Word (Word16, Word32, Word64, Word8)
+import Test.Mutagen.Fragment (sampleFragments)
+import Test.Mutagen.Mutant (Mutant (..))
+import Test.QuickCheck (Arbitrary (..), arbitrary)
 
 {-------------------------------------------------------------------------------
 -- * Mutable types

src/Test/Mutagen/Property.hs

@@ -28,14 +28,14 @@ module Test.Mutagen.Property
   )
 where
 
-import Data.Typeable
-import System.Timeout
+import Data.Typeable (Typeable, cast)
+import System.Timeout (timeout)
 import Test.Mutagen.Exception (AnException, discard, isDiscard, tryEvaluateIO)
-import Test.Mutagen.Fragment
-import Test.Mutagen.Lazy
-import Test.Mutagen.Mutation
+import Test.Mutagen.Fragment (Fragmentable (..))
+import Test.Mutagen.Lazy (Lazy (..))
+import Test.Mutagen.Mutation (Mutable (..))
 import Test.QuickCheck (Arbitrary, Gen, arbitrary)
-import Unsafe.Coerce
+import Unsafe.Coerce (unsafeCoerce)
 
 {-------------------------------------------------------------------------------
 -- * Property arguments

src/Test/Mutagen/Report.hs

@@ -6,7 +6,7 @@ module Test.Mutagen.Report
   )
 where
 
-import Test.Mutagen.Property
+import Test.Mutagen.Property (Args)
 
 {-------------------------------------------------------------------------------
 -- * Testing reports

src/Test/Mutagen/Test/Loop.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE GADTs #-}
+{-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE TypeApplications #-}
 
@@ -11,17 +12,29 @@ module Test.Mutagen.Test.Loop
   )
 where
 
-import Control.Monad
+import Control.Monad (void, when)
 import Control.Monad.Extra (ifM)
 import Control.Monad.IO.Class (MonadIO (..))
 import Data.Function ((&))
 import System.Random (split)
 import Test.Mutagen.Config (DebugMode (..))
-import Test.Mutagen.Fragment
-import Test.Mutagen.Lazy
-import Test.Mutagen.Mutation
+import Test.Mutagen.Fragment (storeFragments)
+import Test.Mutagen.Lazy (Lazy (..), readPosRef, resetPosRef)
+import Test.Mutagen.Mutation (Pos)
 import Test.Mutagen.Property
+  ( Args
+  , Result (..)
+  , protectProp
+  , resultException
+  , resultExpect
+  , unProp
+  , pattern Discarded
+  , pattern Failed
+  , pattern Passed
+  )
 import Test.Mutagen.Report
+  ( Report (..)
+  )
 import Test.Mutagen.Test.Queue
   ( MutationBatch (..)
   , MutationCandidate (..)
@@ -32,7 +45,37 @@ import Test.Mutagen.Test.Queue
   , nextMutation
   )
 import Test.Mutagen.Test.State
+  ( MutagenState (..)
+  , computeSize
+  , incMutantKindCounter
+  , incNumBoring
+  , incNumDiscarded
+  , incNumGenerated
+  , incNumInteresting
+  , incNumMutatedFromDiscarded
+  , incNumMutatedFromPassed
+  , incNumPassed
+  , incNumTestsSinceLastInteresting
+  , incNumTraceLogResets
+  , resetNumTestsSinceLastInteresting
+  , setAutoResetAfter
+  , setCurrentGenSize
+  , setDiscardedQueue
+  , setExpect
+  , setNextSeed
+  , setPassedQueue
+  , setRandomMutations
+  , timedOut
+  , updateFragmentStore
+  , updatePassedQueue
+  )
 import Test.Mutagen.Test.Terminal
+  ( MonadTerminal (..)
+  , pretty
+  , printBatchStatus
+  , printGlobalStats
+  , printShortStats
+  )
 import Test.Mutagen.Tracer.Store (STraceType (..), TraceStoreImpl (..))
 import Test.Mutagen.Tracer.Trace (Trace (..), truncateTrace, withTrace)
 import Test.QuickCheck.Gen (unGen)

src/Test/Mutagen/Tracer/Plugin.hs

@@ -29,14 +29,31 @@ module Test.Mutagen.Tracer.Plugin
   )
 where
 
-import Control.Monad
+import Control.Monad ((>=>))
 import Control.Monad.Writer (MonadIO, WriterT, lift, runWriterT, tell)
 import Data.Generics (Data, everywhereM, listify, mkM)
-import Data.IORef
+import Data.IORef (IORef, atomicModifyIORef', newIORef)
 import GHC.Hs
+  ( AnnDecl (..)
+  , AnnProvenance (..)
+  , GRHS (..)
+  , GhcPs
+  , HsExpr (..)
+  , HsLit (..)
+  , HsMatchContext (..)
+  , HsModule (..)
+  , HsParsedModule (..)
+  , LHsExpr
+  , Match (..)
+  , gHsPar
+  , getLocA
+  , noExtField
+  , noLocA
+  , simpleImportDecl
+  )
 import GHC.Plugins hiding ((<>))
 import GHC.Types.Name.Occurrence as Name
-import GHC.Types.SourceText
+import GHC.Types.SourceText (mkIntegralLit)
 import System.IO.Unsafe (unsafePerformIO)
 import Test.Mutagen.Tracer.Metadata
   ( ModuleMetadata (..)
@@ -46,7 +63,7 @@ import Test.Mutagen.Tracer.Metadata
   , mkSingleModuleTracerMetadata
   , saveTracerMetadata
   )
-import Test.Mutagen.Tracer.Trace
+import Test.Mutagen.Tracer.Trace (TraceNode)
 
 {-------------------------------------------------------------------------------
 -- * GHC Plugin

src/Test/Mutagen/Tracer/Store/API.hs

@@ -9,7 +9,7 @@ module Test.Mutagen.Tracer.Store.API
 where
 
 import Test.Mutagen.Tracer.Store.Types (TraceType)
-import Test.Mutagen.Tracer.Trace
+import Test.Mutagen.Tracer.Trace (Trace)
 
 {-------------------------------------------------------------------------------
 -- * Generic trace store interface

test/re/RE/Types.hs

@@ -4,8 +4,15 @@
 
 module RE.Types where
 
-import Data.String
+import Data.String (IsString (..))
 import Test.Mutagen
+  ( Arbitrary (..)
+  , Fragmentable
+  , Lazy (..)
+  , Mutable (..)
+  , elements
+  )
+import Test.Mutagen.Mutant (Mutant (..))
 import qualified Test.Mutagen.TH as TH
 
 -- | Regular expressions