Prune modules, reduce qualification

ndmitchell · May 3, 2020 · b649373 · b649373
1 parent e757a2c
commit b649373
Show file tree

Hide file tree

Showing 26 changed files with 117 additions and 133 deletions.
diff --git a/hlint.cabal b/hlint.cabal
@@ -117,7 +117,6 @@ library
         GHC.Util.HsDecl
         GHC.Util.HsExpr
         GHC.Util.Module
-        GHC.Util.Outputable
         GHC.Util.SrcLoc
         GHC.Util.DynFlags
         GHC.Util.RdrName

diff --git a/src/Config/Compute.hs b/src/Config/Compute.hs
@@ -15,6 +15,7 @@ import Name
 import Bag
 import Language.Haskell.GhclibParserEx.GHC.Hs.ExtendInstances
 import Language.Haskell.GhclibParserEx.GHC.Hs.Expr
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 import SrcLoc
 import Prelude
 

diff --git a/src/Config/Haskell.hs b/src/Config/Haskell.hs
@@ -15,7 +15,7 @@ import Prelude
 
 import GHC.Util
 
-import SrcLoc as GHC
+import SrcLoc
 import GHC.Hs.Extension
 import GHC.Hs.Decls hiding (SpliceDecl)
 import GHC.Hs.Expr hiding (Match)
@@ -25,6 +25,7 @@ import ApiAnnotation
 import OccName
 import Outputable
 
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 
 -- | Read an {-# ANN #-} pragma and determine if it is intended for HLint.
 --   Return Nothing if it is not an HLint pragma, otherwise what it means.
@@ -46,7 +47,7 @@ readPragma (HsAnnotation _ _ provenance expr) = f expr
         f _ = Nothing
 readPragma _ = Nothing
 
-readComment :: GHC.Located AnnotationComment -> [Classify]
+readComment :: Located AnnotationComment -> [Classify]
 readComment c@(L pos AnnBlockComment{})
     | (hash, x) <- maybe (False, x) (True,) $ stripPrefix "#" x
     , x <- trim x
@@ -79,7 +80,7 @@ errorOn (L pos val) msg = exitMessageImpure $
     ": Error while reading hint file, " ++ msg ++ "\n" ++
     unsafePrettyPrint val
 
-errorOnComment :: GHC.Located AnnotationComment -> String -> b
+errorOnComment :: Located AnnotationComment -> String -> b
 errorOnComment c@(L s _) msg = exitMessageImpure $
     let isMultiline = isCommentMultiline c in
     showSrcSpan' s ++

diff --git a/src/Config/Yaml.hs b/src/Config/Yaml.hs
@@ -30,13 +30,13 @@ import Timing
 import Prelude
 
 import Bag
-import qualified Lexer as GHC
-import qualified ErrUtils
-import qualified Outputable
+import Lexer
+import ErrUtils hiding (Severity)
+import Outputable
 import GHC.Hs
 import SrcLoc
-import qualified RdrName as GHC
-import qualified OccName as GHC
+import RdrName
+import OccName
 import GHC.Util (baseDynFlags, Scope,scopeCreate)
 import Language.Haskell.GhclibParserEx.GHC.Hs.ExtendInstances
 import Data.Char
@@ -161,13 +161,13 @@ allowFields v allow = do
     when (bad /= []) $
         parseFail v $ "Not allowed keys: " ++ unwords bad
 
-parseGHC :: (ParseFlags -> String -> GHC.ParseResult v) -> Val -> Parser v
+parseGHC :: (ParseFlags -> String -> ParseResult v) -> Val -> Parser v
 parseGHC parser v = do
     x <- parseString v
-    case parser defaultParseFlags{extensions=configExtensions} x of
-        GHC.POk _ x -> pure x
-        GHC.PFailed ps ->
-          let (_, errs) = GHC.getMessages ps baseDynFlags
+    case parser defaultParseFlags{enabledExtensions=configExtensions} x of
+        POk _ x -> pure x
+        PFailed ps ->
+          let (_, errs) = getMessages ps baseDynFlags
               errMsg = head (bagToList errs)
               msg = Outputable.showSDoc baseDynFlags $ ErrUtils.pprLocErrMsg errMsg
           in parseFail v $ "Failed to parse " ++ msg ++ ", when parsing:\n " ++ x
@@ -277,8 +277,8 @@ parseWithin :: Val -> Parser [(String, String)] -- (module, decl)
 parseWithin v = do
     x <- parseGHC parseExpGhcWithMode v
     case x of
-        L _ (HsVar _ (L _ (GHC.Unqual x))) -> pure $ f "" (GHC.occNameString x)
-        L _ (HsVar _ (L _ (GHC.Qual mod x))) -> pure $ f (moduleNameString mod) (GHC.occNameString x)
+        L _ (HsVar _ (L _ (Unqual x))) -> pure $ f "" (occNameString x)
+        L _ (HsVar _ (L _ (Qual mod x))) -> pure $ f (moduleNameString mod) (occNameString x)
         _ -> parseFail v "Bad classification rule"
     where
         f mod name@(c:_) | isUpper c = [(mod,name),(mod ++ ['.' | mod /= ""] ++ name, "")]
@@ -300,7 +300,7 @@ guessName lhs rhs
     where
         (ls, rs) = both f (lhs, rhs)
         f :: LHsExpr GhcPs -> [String]
-        f x = [y | L _ (HsVar _ (L _ x)) <- universe x, let y = GHC.occNameString $ GHC.rdrNameOcc x, not $ isUnifyVar y, y /= "."]
+        f x = [y | L _ (HsVar _ (L _ x)) <- universe x, let y = occNameString $ rdrNameOcc x, not $ isUnifyVar y, y /= "."]
 
 
 asNote :: String -> Note

diff --git a/src/GHC/Util.hs b/src/GHC/Util.hs
@@ -8,15 +8,13 @@ module GHC.Util (
   , module GHC.Util.HsDecl
   , module GHC.Util.HsExpr
   , module GHC.Util.Module
-  , module GHC.Util.Outputable
   , module GHC.Util.SrcLoc
   , module GHC.Util.DynFlags
   , module GHC.Util.Scope
   , module GHC.Util.RdrName
   , module GHC.Util.Unify
-
   , parsePragmasIntoDynFlags
-  , parseFileGhcLib, parseExpGhcLib, parseImportGhcLib, parseDeclGhcLib
+  , fileToModule
   , pattern SrcSpan, srcSpanFilename, srcSpanStartLine', srcSpanStartColumn, srcSpanEndLine', srcSpanEndColumn
   , pattern SrcLoc, srcFilename, srcLine, srcColumn
   , showSrcSpan',
@@ -28,15 +26,15 @@ import GHC.Util.ApiAnnotation
 import GHC.Util.HsExpr
 import GHC.Util.HsDecl
 import GHC.Util.Module
-import GHC.Util.Outputable
 import GHC.Util.SrcLoc
 import GHC.Util.DynFlags
 import GHC.Util.RdrName
 import GHC.Util.Scope
 import GHC.Util.Unify
 
-import qualified Language.Haskell.GhclibParserEx.GHC.Parser as GhclibParserEx
+import Language.Haskell.GhclibParserEx.GHC.Parser (parseFile)
 import Language.Haskell.GhclibParserEx.GHC.Driver.Session (parsePragmasIntoDynFlags)
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 
 import GHC.Hs
 import Lexer
@@ -47,18 +45,9 @@ import FastString
 import System.FilePath
 import Language.Preprocessor.Unlit
 
-parseExpGhcLib :: String -> DynFlags -> ParseResult (LHsExpr GhcPs)
-parseExpGhcLib = GhclibParserEx.parseExpression
-
-parseImportGhcLib :: String -> DynFlags -> ParseResult (LImportDecl GhcPs)
-parseImportGhcLib = GhclibParserEx.parseImport
-
-parseDeclGhcLib :: String -> DynFlags -> ParseResult (LHsDecl GhcPs)
-parseDeclGhcLib = GhclibParserEx.parseDeclaration
-
-parseFileGhcLib :: FilePath -> String -> DynFlags -> ParseResult (Located (HsModule GhcPs))
-parseFileGhcLib filename str flags =
-  GhclibParserEx.parseFile filename flags
+fileToModule :: FilePath -> String -> DynFlags -> ParseResult (Located (HsModule GhcPs))
+fileToModule filename str flags =
+  parseFile filename flags
     (if takeExtension filename /= ".lhs" then str else unlit filename str)
 
 {-# COMPLETE SrcSpan #-}

diff --git a/src/GHC/Util/HsExpr.hs b/src/GHC/Util/HsExpr.hs
@@ -24,7 +24,6 @@ import Bag(bagToList)
 import GHC.Util.Brackets
 import GHC.Util.View
 import GHC.Util.FreeVars
-import GHC.Util.Outputable (unsafePrettyPrint)
 
 import Control.Applicative
 import Control.Monad.Trans.State
@@ -41,6 +40,7 @@ import qualified Refact.Types as R (SrcSpan)
 import Language.Haskell.GhclibParserEx.GHC.Hs.Pat
 import Language.Haskell.GhclibParserEx.GHC.Hs.Expr
 import Language.Haskell.GhclibParserEx.GHC.Hs.ExtendInstances
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 
 -- | 'dotApp a b' makes 'a . b'.
 dotApp' :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs

diff --git a/src/GHC/Util/Outputable.hs b/src/GHC/Util/Outputable.hs
diff --git a/src/GHC/Util/Scope.hs b/src/GHC/Util/Scope.hs
@@ -1,3 +1,4 @@
+
 {-# LANGUAGE ViewPatterns #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 
@@ -16,7 +17,7 @@ import OccName
 
 import GHC.Util.Module
 import GHC.Util.RdrName
-import GHC.Util.Outputable
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 
 import Data.List.Extra
 import Data.Maybe

diff --git a/src/GHC/Util/Unify.hs b/src/GHC/Util/Unify.hs
@@ -16,14 +16,14 @@ import Data.List.Extra
 import Util
 
 import GHC.Hs
-import SrcLoc as GHC
+import SrcLoc
 import Outputable hiding ((<>))
 import RdrName
 import OccName
 
 import Language.Haskell.GhclibParserEx.GHC.Hs.Pat
 import Language.Haskell.GhclibParserEx.GHC.Hs.Expr
-import GHC.Util.Outputable
+import Language.Haskell.GhclibParserEx.GHC.Utils.Outputable
 import GHC.Util.HsExpr
 import GHC.Util.RdrName
 import GHC.Util.View
@@ -106,7 +106,7 @@ unify' nm root x y
     | Just (x, y) <- cast (x, y) = unifyExp' nm root x y
     | Just (x, y) <- cast (x, y) = unifyPat' nm x y
     | Just (x, y) <- cast (x, y) = unifyType' nm x y
-    | Just (x :: GHC.SrcSpan) <- cast x = Just mempty
+    | Just (x :: SrcSpan) <- cast x = Just mempty
     | otherwise = unifyDef' nm x y
 
 unifyDef' :: Data a => NameMatch' -> a -> a -> Maybe (Subst' (LHsExpr GhcPs))