Add -W flag to many files, mostly getting rid of dead imports

compiler/Build/Dependencies.hs

@@ -1,12 +1,11 @@
+{-# OPTIONS_GHC -W #-}
 module Build.Dependencies (getSortedDependencies) where
 
-import Data.Data
 import Control.Applicative
 import Control.Monad.Error
 import qualified Control.Monad.State as State
 import qualified Data.Aeson as Json
 import qualified Data.ByteString.Lazy.Char8 as BSC
-import qualified Data.Char as Char
 import qualified Data.Graph as Graph
 import qualified Data.List as List
 import qualified Data.Map as Map
@@ -16,19 +15,11 @@ import System.Directory
 import System.Exit
 import System.FilePath as FP
 import System.IO
-import Text.PrettyPrint (Doc)
 
 import qualified SourceSyntax.Module as Module
-import qualified SourceSyntax.Type as Type
 import qualified Parse.Parse as Parse
-import qualified Transform.Check as Check
-import qualified Transform.SortDefinitions as SD
-import qualified Type.Inference as TI
-import qualified Type.Constrain.Declaration as TcDecl
-import qualified Transform.Canonicalize as Canonical
 import qualified Elm.Internal.Paths as Path
 import qualified Elm.Internal.Name as N
-import qualified Elm.Internal.Version as V
 import qualified Elm.Internal.Dependencies as Deps
 
 getSortedDependencies :: [FilePath] -> Module.Interfaces -> FilePath -> IO [String]

compiler/Build/File.hs

@@ -1,8 +1,8 @@
+{-# OPTIONS_GHC -W #-}
 module Build.File (build) where
 
 import Control.Monad (when)
 import qualified Data.Binary as Binary
-import qualified Data.List as List
 import qualified Data.Map as Map
 import System.Directory
 import System.Exit

compiler/Build/Source.hs

@@ -1,13 +1,8 @@
+{-# OPTIONS_GHC -W #-}
 module Build.Source (build) where
 
-import Data.Data
-import Control.Monad.State
-import qualified Data.Graph as Graph
-import qualified Data.List as List
 import qualified Data.Map as Map
 import qualified Data.Set as Set
-import System.Directory
-import System.Exit
 import System.FilePath as FP
 import Text.PrettyPrint (Doc)
 

compiler/Compiler.hs

@@ -1,7 +1,7 @@
+{-# OPTIONS_GHC -W #-}
 module Main where
 
 import Control.Monad (foldM)
-import qualified Data.Map as Map
 import qualified Data.Maybe as Maybe
 import Text.Blaze.Html.Renderer.String (renderHtml)
 import qualified Data.ByteString.Lazy.Char8 as BS
@@ -37,7 +37,7 @@ build flags rootFile =
                 then getSortedDependencies (Flag.src_dir flags) builtIns rootFile
                 else return [rootFile]
 
-       (moduleName, interfaces) <-
+       (moduleName, _) <-
            File.build flags (length files) builtIns "" files
 
        js <- foldM appendToOutput BS.empty files

compiler/Generate/Cases.hs

@@ -1,9 +1,9 @@
 module Generate.Cases (toMatch, Match (..), Clause (..), matchSubst, newVar) where
 
-import Control.Applicative ((<$>),(<*>))
-import Control.Arrow (first,second)
+import Control.Applicative ((<$>))
+import Control.Arrow (first)
 import Control.Monad.State
-import Data.List (groupBy,sortBy,lookup)
+import Data.List (groupBy,sortBy)
 import Data.Maybe (fromMaybe)
 
 import SourceSyntax.Location
@@ -47,7 +47,7 @@ matchSubst pairs (Match n cs m) =
               clauseSubst (Clause c vs m) =
                   Clause c (map varSubst vs) (matchSubst pairs m)
 
-isCon (p:ps, e) =
+isCon (p:_, _) =
   case p of
     PData _ _  -> True
     PLiteral _ -> True
@@ -75,7 +75,7 @@ dealias v c@(p:ps, L s e) =
 matchVar :: [String] -> [([Pattern],LExpr)] -> Match -> State Int Match
 matchVar (v:vs) cs def = match vs (map subVar cs) def
   where
-    subVar (p:ps, ce@(L s e)) = (ps, L s $ subOnePattern p e)
+    subVar (p:ps, (L s e)) = (ps, L s $ subOnePattern p e)
         where
           subOnePattern pattern e =
             case pattern of
@@ -109,7 +109,7 @@ matchClause :: Either String Literal
             -> [([Pattern],LExpr)]
             -> Match
             -> State Int Clause
-matchClause c (v:vs) cs def =
+matchClause c (_:vs) cs def =
     do vs' <- getVars
        Clause c vs' <$> match (vs' ++ vs) (map flatten cs) def
     where

compiler/InterfaceSerialization.hs

@@ -1,3 +1,4 @@
+{-# OPTIONS_GHC -W #-}
 module InterfaceSerialization ( loadInterface
                               , interfaceDecode
                               , validVersion
@@ -8,8 +9,6 @@ import qualified Data.Binary as Binary
 
 import qualified Elm.Internal.Version as Version
 import System.Directory (doesFileExist)
-import System.IO (hPutStrLn, stderr)
-import System.Exit (exitFailure)
 
 import SourceSyntax.Module
 

compiler/Metadata/Prelude.hs

@@ -1,15 +1,12 @@
+{-# OPTIONS_GHC -W #-}
 module Metadata.Prelude (interfaces, add) where
 
 import qualified Data.Map as Map
 import qualified Control.Exception as E
 import qualified Paths_Elm as Path
-import System.Directory
 import System.Exit
-import System.FilePath
 import System.IO
 import SourceSyntax.Module
-import qualified Data.Binary as Binary
-import qualified Data.ByteString.Lazy as BS
 
 import qualified InterfaceSerialization as IS
 
@@ -20,7 +17,7 @@ add noPrelude (Module name exs ims decls) = Module name exs (customIms ++ ims) d
 
       addModule (n, method) = case lookup n ims of
                                 Nothing     -> [(n, method)]
-                                Just (As m) -> [(n, method)]
+                                Just (As _) -> [(n, method)]
                                 Just _      -> []
 
 prelude :: [(String, ImportMethod)]

compiler/Parse/Parse.hs

@@ -1,21 +1,16 @@
+{-# OPTIONS_GHC -W #-}
 module Parse.Parse (program, dependencies) where
 
 import Control.Applicative ((<$>), (<*>))
-import Control.Monad
-import Data.Char (isSymbol, isDigit)
-import Data.List (foldl',intercalate)
+import qualified Data.List as List
 import qualified Data.Map as Map
 import Text.Parsec hiding (newline,spaces)
 import qualified Text.PrettyPrint as P
 
-import qualified SourceSyntax.Expression as E
 import qualified SourceSyntax.Declaration as D
 import qualified SourceSyntax.Module as M
 import Parse.Helpers
-import Parse.Binop (OpTable)
-import Parse.Expression
 import Parse.Declaration (infixDecl)
-import Parse.Type
 import Parse.Module
 import qualified Parse.Declaration as Decl
 import Transform.Declaration (combineAnnotations)
@@ -45,7 +40,7 @@ programParser =
 
 dependencies :: String -> Either [P.Doc] (String, [String])
 dependencies =
-    let getName = intercalate "." . fst in
+    let getName = List.intercalate "." . fst in
     setupParser $ do
       optional freshLine
       (,) <$> option "Main" (getName <$> moduleDef `followedBy` freshLine)
@@ -64,7 +59,7 @@ setupParserWithTable table p source =
       msg overlap =
           P.vcat [ P.text "Parse error:"
                  , P.text $ "Overlapping definitions for infix operators: " ++
-                          intercalate " " (Map.keys overlap)
+                          List.intercalate " " (Map.keys overlap)
                  ]
 
 parseFixities = do

compiler/Parse/Pattern.hs

@@ -1,13 +1,10 @@
-
+{-# OPTIONS_GHC -W #-}
 module Parse.Pattern (term, expr) where
 
-import Control.Applicative ((<$>),(<*>),pure)
-import Control.Monad
-import Control.Monad.State
+import Control.Applicative ((<$>))
 import Data.Char (isUpper)
 import Data.List (intercalate)
 import Text.Parsec hiding (newline,spaces,State)
-import Text.Parsec.Indent
 
 import Parse.Helpers
 import Parse.Literal
@@ -20,9 +17,10 @@ basic = choice
     [ char '_' >> return PAnything
     , do v <- var
          return $ case v of
-                    "True"  -> PLiteral (Boolean True)
-                    "False" -> PLiteral (Boolean False)
-                    c : _   -> if isUpper c then PData v [] else PVar v
+                    "True"          -> PLiteral (Boolean True)
+                    "False"         -> PLiteral (Boolean False)
+                    c:_ | isUpper c -> PData v []
+                    _               -> PVar v
     , PLiteral <$> literal
     ]
 

compiler/Type/Environment.hs

@@ -1,3 +1,4 @@
+{-# OPTIONS_GHC -W #-}
 module Type.Environment where
 
 import Control.Applicative ((<$>), (<*>))
@@ -9,7 +10,6 @@ import qualified Control.Monad.State as State
 import qualified Data.Traversable as Traverse
 import qualified Data.Map as Map
 import Data.List (isPrefixOf)
-import qualified Data.UnionFind.IO as UF
 import qualified Text.PrettyPrint as PP
 
 import qualified SourceSyntax.Type as Src
@@ -44,7 +44,7 @@ makeTypes datatypes =
   where
     nameAndKind (name, tvars, _, _) = (name, length tvars)
 
-    makeCtor (name, kind) = do
+    makeCtor (name, _) = do
       ctor <- VarN <$> namedVar Constant name
       return (name, ctor)
 
@@ -84,7 +84,7 @@ makeConstructors env datatypes = Map.fromList builtins
 
 
 ctorToType :: Environment -> ADT -> [ (String, IO (Int, [Variable], [Type], Type)) ]
-ctorToType env (name, tvars, ctors, derivations) =
+ctorToType env (name, tvars, ctors, _) =
     zip (map fst ctors) (map inst ctors)
   where
     inst :: (String, [Src.Type]) -> IO (Int, [Variable], [Type], Type)
@@ -94,7 +94,7 @@ ctorToType env (name, tvars, ctors, derivations) =
       
 
     go :: (String, [Src.Type]) -> State.StateT (VarDict, TypeDict) IO ([Type], Type)
-    go (ctor, args) = do
+    go (_, args) = do
       types <- mapM (instantiator env) args
       returnType <- instantiator env (Src.Data name (map Src.Var tvars))
       return (types, returnType)

compiler/Type/ExtraChecks.hs

@@ -1,7 +1,8 @@
+{-# OPTIONS_GHC -W #-}
+module Type.ExtraChecks (extraChecks, occursCheck) where
 -- This module contains checks to be run *after* type inference has
 -- completed successfully. At that point we still need to do occurs
 -- checks and ensure that `main` has an acceptable type.
-module Type.ExtraChecks (extraChecks, occursCheck) where
 
 import Control.Applicative ((<$>),(<*>))
 import Control.Monad.State
@@ -14,7 +15,6 @@ import Text.PrettyPrint as P
 import SourceSyntax.PrettyPrint (pretty)
 import SourceSyntax.Type (Type)
 import qualified SourceSyntax.Location as Location
-import qualified SourceSyntax.Expression as Expr
 import qualified Data.Traversable as Traverse
 
 extraChecks :: Alias.Rules -> TS.Env -> IO (Either [P.Doc] (Map.Map String Type))
@@ -47,7 +47,7 @@ occursCheck (name, variable) =
          case structure desc of
            Nothing ->
                modify $ \state -> state { TS.sErrors = fallback : TS.sErrors state }
-           Just struct ->
+           Just _ ->
                do liftIO $ UF.setDescriptor var (desc { structure = Nothing })
                   var' <- liftIO $ UF.fresh desc
                   TS.addError (Location.NoSpan name) (Just msg) var var'

compiler/Type/Inference.hs

@@ -1,3 +1,4 @@
+{-# OPTIONS_GHC -W #-}
 module Type.Inference where
 
 import qualified Data.Map as Map
@@ -5,20 +6,16 @@ import qualified Data.Map as Map
 import qualified Type.Type as T
 import qualified Type.Environment as Env
 import qualified Type.Constrain.Expression as TcExpr
-import qualified Type.Constrain.Declaration as TcDecl
 import qualified Type.Solve as Solve
 
 import SourceSyntax.Module as Module
-import qualified SourceSyntax.Expression as Expr
-import SourceSyntax.Location (Located, noneNoDocs)
-import SourceSyntax.PrettyPrint
+import SourceSyntax.Location (noneNoDocs)
 import SourceSyntax.Type (Type)
 import Text.PrettyPrint
 import qualified Type.State as TS
 import Type.ExtraChecks (extraChecks)
 import Control.Monad.State (execStateT, forM)
 import Control.Monad.Error (runErrorT, liftIO)
-import Control.Arrow (second)
 import qualified Type.Alias as Alias
 
 import System.IO.Unsafe  -- Possible to switch over to the ST monad instead of

compiler/Type/Solve.hs

@@ -1,3 +1,4 @@
+{-# OPTIONS_GHC -W #-}
 module Type.Solve (solve) where
 
 import Control.Monad
@@ -5,14 +6,11 @@ import Control.Monad.State
 import qualified Data.UnionFind.IO as UF
 import qualified Data.Map as Map
 import qualified Data.Traversable as Traversable
-import qualified Data.Maybe as Maybe
 import qualified Data.List as List
 import Type.Type
 import Type.Unify
 import qualified Type.ExtraChecks as EC
-import qualified Type.Environment as Env
 import qualified Type.State as TS
-import qualified Text.PrettyPrint as P
 import SourceSyntax.Location (Located(L), SrcSpan)
 
 

compiler/Type/State.hs

@@ -1,9 +1,8 @@
+{-# OPTIONS_GHC -W #-}
 module Type.State where
 
 import Type.Type
 import qualified Data.Map as Map
-import qualified Data.List as List
-import qualified Type.Environment as Env
 import qualified Data.UnionFind.IO as UF
 import Control.Monad.State
 import Control.Applicative ((<$>),(<*>), Applicative)
@@ -11,7 +10,6 @@ import qualified Data.Traversable as Traversable
 import Text.PrettyPrint as P
 import SourceSyntax.PrettyPrint
 import SourceSyntax.Location
-import qualified SourceSyntax.Type as Src
 import qualified Type.Alias as Alias
 
 -- Pool
@@ -64,8 +62,8 @@ addError span hint t1 t2 =
          ]
 
     location = case span of
-                 NoSpan msg -> ""
-                 Span p1 p2 msg ->
+                 NoSpan _ -> ""
+                 Span p1 p2 _ ->
                      if line p1 == line p2 then " on line " ++ show (line p1)
                      else " between lines " ++ show (line p1) ++ " and " ++ show (line p2)
 

compiler/Type/Unify.hs

@@ -1,3 +1,4 @@
+{-# OPTIONS_GHC -W #-}
 module Type.Unify (unify) where
 
 import Type.Type
@@ -5,7 +6,6 @@ import qualified Data.UnionFind.IO as UF
 import qualified Data.Map as Map
 import qualified Data.Maybe as Maybe
 import qualified Type.State as TS
-import Control.Arrow (first,second)
 import Control.Monad.State
 import SourceSyntax.Location
 import Type.PrettyPrint
@@ -193,8 +193,8 @@ actuallyUnify span variable1 variable2 = do
 
                 unmerged a b = Map.filter (not . null) $ Map.union (Map.intersectionWith eat a b) a
 
-                eat (x:xs) (y:ys) = eat xs ys
-                eat xs ys = xs
+                eat (_:xs) (_:ys) = eat xs ys
+                eat xs _ = xs
 
           _ -> TS.addError span Nothing variable1 variable2