diff --git a/ChangeLog b/ChangeLog new file mode 100644 index 0000000..1c7f6f5 --- /dev/null +++ b/ChangeLog @@ -0,0 +1,325 @@ +2017-05-26 v5.8.0.0 + * Fix logic bug in fix for excessive use of `map-file` + * Bump HLint to 2.x + * Reorganize Cabal file to make maintanance easier + * Merge #872, Do not log warning when Stack project is preferred + * Merge #873, Fix build on case-insensitive filesystems + * Fix 'debug' command when ghc(-pkg) not on PATH + * Rework README + * Reorganize modules as preparation for splitting off ghc-mod-core + * Remove dependency on 'pretty' and use GHC's pretty printer instead + * Merge #854, Fix for "ghc-mod doc" when usind with stack + * Merge #858, Fix Gap.fromTyThing returning GHC internal + representation instead of the user readable representation of + types + * Fix #774, 'find*File' searching all the way up to / + * Fix #778, Check directory permissions before reading in + findFileInParentsP + * Merge #817, fix #779, bad "ghc-mod check" performance + +2017-01-16 v5.7.0.0 + * Bump cabal-helper to 0.7.3.0 to support Cabal-1.24.1.0 + * Bump haskell-src-exts, optparse-applicative, pipes and extra + to be compatible with stackage. + +2016-07-29 v5.6.0.0 + * Bump cabal-helper to 0.7, adds support for Cabal-1.24 + * Merge #737, `map-file` caching issues + * Merge #767, Add `browse` option to show symbol "parents" + * Merge #731, Type constraints + * Fix #69 (via #731), Missing type constraints + * Fix #438, Case splitting not working + * Fix #790, Don't try to use 'cabal' or 'stack' when it's not installed + * Add support for GHC 8.0 + +2016-01-19 v5.5.0.0 + * Fix #660, cabal-helper errors when no global GHC is installed (Stack) + * Fix #665, Reinstate internally managed CWD (no more `ghc-mod root` + requirement for frontends) + * Merge #707, Support for spaces in file names when using + legacy-interactive + * Merge #694, #706, #703, Rewrite command line parser using + optparse-applicative. Thanks @lierdakil! + * Merge #693, Fix slowdown and bugs caused by excessive use of + `map-file` + * Fix #678, "No instance nor default method for class operation put" + * Fix #683, #684, a variety of caching related issues + * Fix #666, The issue of the beast >:3 + * Merge #649, elisp: Add ghc-report-errors to inhibit *GHC Error* + logging + * Fix #621, Preserve Cabal flag selection across automatic + reconfiguration + +2015-09-16 v5.4.0.0 + * Add support for the Stack build tool + * Fix #554, `module not interpreted` errors when using the `type` + command + * Merge #484, support for file redirection + * Add support for file redirection to Emacs frontend so + all commands should work even with unsaved files now! + * Support inserting holes in type signatures + * Merge #543, Fix URL anchors being dropped in OS X + * Fix GHC session always being dropped in interactive mode (caused + super slowness) + * Expose all internal modules because API will get a major + redesign soon anyways + * ghc-mod(i) executable must now be run in project directory for + commands other than `root` + * Add --line-prefix option for multiplexing stdout/err onto one stream + +2015-08-14 v5.3.0.0 + * Re-license majority of code under the AGPL-3 + * Add support for GHC 7.10 and Cabal 1.22 + * Remove `cabalDependPackages', `cabalAllTargets' + * Merge #434, Fix finding sandbox config file and directory. + * Merge #431, Re-add output line separator global option for expand + command. + * Merge #470, Support for overriding the package-db stack + * Merge #486, Fix ineffective cache invalidation for `find` + +2014-12-31 v5.2.1.2 + * Merge #377, Fix `browse` erroneously thinking haskell2010 identifiers + are operators + * Fix incompatibility with monad-control >= 1.0.0 + * Fix temporary directories not being removed properly + * Merge #405, #408, a race condition in the Emacs frontend + * Merge #403, Support unicode quotes in module regexp + +2014-11-03 v5.2.1.1 + * Fix `findCabalFiles` thinking `$HOME/.cabal` is a cabal file. + * Support `where` clauses, `let` bindings and `case` expressions + in case splitting, #400 + +2014-11-02 v5.2.1.0 + * Fix `newTempDir` on Windows + * GhcModT's liftIO instance now converts GhcMOdError exceptions + into monadic failures + +2014-10-30 v5.2.0.0 + * Return type of `loadSymbolDb` is now in GhcModT + * Function `dumpSymbol` now takes the path of the target directory + * Fix #387, Pattern match failure in GhcPkg + * Fix #386, `ghc-mod version` should not check `cabal configure` + * Fix #391, Error on command `-g` when used before command despite + --help output saying this is valid + * Fix formatting of `ghc-version` constant in the elisp code. in + version 5.1.1.0 the string was "v5.1.1.0" instead of "5.1.1.0". + +2014-10-04 v5.1.1.0 + * Handle various consistency related issues: #222, #224, #326, #332 + * Add `isOutdated` to Language.Haskell.GhcMod + +2014-09-17 v5.1.0.2 + * Fix building with haskell-src-exts < 1.16.0 + +2014-09-16 v5.1.0.1 + * Fix building with haskell-src-exts-1.16.0 + * Loosen monad-journal dependency + +2014-09-12 v5.1.0.0 + * GhcModError is now a recursive data type (`GMECabalConfigure`'s + type changed) + * GhcModT's MonadIO instance now converts IOError's to failures in + the ErrorT part of GhcModT on `liftIO`. + * Make `loadSymbolDb` polimorphic in the return types's monad. + * Add `hoistGhcModT` to Language.Haskell.GhcMod.Internal + * Fix `check` command for modules using `-XPatternSynonyms` + * Merge #364, Support cabal configuration flags + +2014-08-29 v5.0.1.2 + * Merge #345, Try fixing duplicate errors + * Merge #344, elisp: Use advice to check syntax on save-buffer + * Merge #341, support `browse -d` in ghc-modi + * Merge #352, elisp: Fix C-u accidentally getting turned into a + prefix command + +2014-08-24 v5.0.1.1 + * Fix CaseSplitting faliure when using "fancy types" (see #336) + * Print error information in "spec" test suite when using `extract` + +2014-08-20 v5.0.1 + * Fix missing file in "Data-Files" + +2014-08-20 v5.0.0 + * ghc-mod consumes much less memory than ghc-mod-4.1. + * @serras brought the results of Google Summer code + including case splitting and better type hole + * @DanielG provided the new monad based API + +2014-05-16 v4.1.6 + * Reverting "Trying to fix rare hang on Nix". + +2014-05-16 v4.1.5 + * Fixing the build on GHC 7.8.3. + +2014-05-16 v4.1.4 + * Trying to fix rare hang on Nix. + +2014-05-16 v4.1.3 + * Making -g-fxxx work. + +2014-05-16 v4.1.2 + * Setting Opt_WarnTypedHoles correctly. + +2014-05-16 v4.1.1 + * Making Emacs front-end more stable. + +2014-04-30 v4.1.0 + * ghc-modi now provides "type", "info", and "boot". + * ghc-mod now provides "find". + * Packages, which are specified in a cabal file but not installed, + are filtered out. (@DanielG) + * ghc-mod/ghc-modi treats "-l" properly. + * ghc-mod obsoletes "-p". Use "ghc-mod browse package:module". + * M-x ghc-debug has been implemented. + * "type" and "info" can work even if files contain type errors. + * "boot" as a new API. + +2014-04-07 v4.0.2 + * The ghc-display-error option (@notogawa) + * Fixing a file bug for Windows (@Kiripon) + * The -b option for ghc-modi (@yuga) + +2014-04-03 v4.0.1 + * Displaying a qualified name for one if two unqualified names + are conflict. + +2014-04-01 v4.0.0 + * Implementing interactive "ghc-modi" command. + "check", "find", and "lint" are available. + * Introducing a concept of project root directory. + Thanks to this, sandbox without cabal can be used. + "ghd-mod debug" displays the project root. + * Syntax error highlighting (C-xC-s) gets much faster + thanks to ghc-modi. "flymake" was thrown away and + syntax error highlighting is implemented from a scratch. + * Resolving the "import hell". You dont' have to type + "import Foo" anymore. Use M-t or C-cC-m. + * Inserting "module Foo" (M-t) can insert all paths + relative to the project root. + * M-C-d displays a html document even if it is in its sandbox. + * M-s now merges the same module lines in addition to sorting. + * A bug fix for hlint support. (@eagletmt) + +2014-03-15 v3.1.7 + * Defining ghc-debug for Elisp debugging. + * Catching up the latest hlint which does not provide --quite. + +2014-02-07 v3.1.6 + * Testing with multi GHC versions. (@eagletmt) + * Checking package ID. (@naota) + * Supporting GHC 7.8.1 RC1. (@bartavelle) + +2014-01-14 v3.1.5 + * Catching up to GHC 7.7. (@scottgw) + * Testing with multi GHC versions. (@eagletmt) + * Workaround for the coming new Haskell Platform. + * Supporting flymake of the coming Emacs 24.4. + +2013-11-20 v3.1.4 + * GHCi loading as fallback for browse. (@khorser) + * Supporting GHC 7.7. (@schell) + * Introducing the "-p" and "-q" option for browse. (@mvoidex) + +2013-10-07 v3.1.3 + * Fixing tests. (@eagletmt) + +2013-09-21 v3.1.2 + * Supporting sandbox for "list" and "browse". (@eagletmt) + +2013-09-21 v3.1.1 + * Making Cradle strict. + +2013-09-21 v3.1.0 + * API breaks backward compatibility. + * Supporting sandbox sharing. + +2013-09-16 v3.0.2 + * Fixing a bug of "dist/build/autogen/cabal_macros.h". + +2013-09-16 v3.0.1 + * Exporting more low level APIs. + * Adding "-ibuild/autogen" + * Adding "-optP". (Macros from a Cabal file + and "dist/build/autogen/cabal_macros.h") + +2013-09-06 v3.0.0 + * Supporting the sandbox of cabal 1.18. + * Obsoleting the support for cabal-dev. + +2013-09-04 v2.1.2 + * Supporting multiple target files. (@nh2) + +2013-09-03 v2.1.1 + * A bug fix for library dependency. + +2013-09-03 v2.1.0 + * Exporting Language.Haskell.GhcMod.Internal. (@alanz) + * Supporting GHC 7.7. (@co-dan) + +2013-05-30 v2.0.3 + * Using finalizePackageDescription to enable "if else" in a cabal + file. + +2013-05-21 v2.0.2 + * Document fixes. + +2013-05-21 v2.0.1 + * Document fixes. + +2013-05-21 v2.0.0 + * ghc-mod also provides a library (Language.Haskell.GhcMod) + +2013-05-13 v1.12.5 + * A bug fix for the case where a cabal file is broken. + +2013-04-02 v1.12.4 + + * C-M-d on Emacs now can browse functions and types. + * Checking "QuasiQuotes" as well as "TemplateHaskell". (@eagletmt) + * "ghc-mod info" can display info of non-exported functions. + (@mvoidex) + +2013-03-16 v1.12.3 + + * "ghc-mod info" and "ghc-mod type" also check Template Haskell. + (@eagletmt) + +2013-03-13 v1.12.2 + + * New logic to set "-fno-code" using "depanal" + * Cleaning up the code relating to Doc/SDoc + +2013-03-07 v1.12.1 + + * Fixing a bug to find a sandbox. + +2013-03-05 v1.12.0 + + * "ghc-mod debug" to see which cabal file and sand box are used + * Fast "ghc-mod check" if Template Haskell is not used + * "ghc-mod brwose -d" displays more information (@eagletmt) + +2013-03-01 v1.11.5 + + * New option "-d" for "ghc-mod browse" to show symbols with type + info (@moidex) + +2013-02-15 v1.11.4 + + * Adding Hspec test suite + * Better way to show Extension (@eagletmt) + * Removing the library itself from Cabal dependencies + +2012-12-11 v1.11.3 + + * Display a filname instead of "Dummy" if an error occur + +2012-10-30 v1.11.2 + + * Extract dependencies from a Cabal file if exists and specify + them to "ghc-mod check" (@khibino) + +2012-10-19 v1.11.1 + + * Supporting GHC 7.6.x (@cartazio, @dysinger, @ihameed) diff --git a/GhcMod.hs b/GhcMod.hs index 551e30b..8934759 100644 --- a/GhcMod.hs +++ b/GhcMod.hs @@ -69,24 +69,24 @@ module GhcMod ( , unloadMappedFile ) where -import GhcModExe.Boot -import GhcModExe.Browse -import GhcModExe.CaseSplit -import GhcModExe.Check -import GhcModExe.Debug -import GhcModExe.FillSig -import GhcModExe.Find -import GhcModExe.Flag -import GhcModExe.Info -import GhcModExe.Lang -import GhcModExe.Lint -import GhcModExe.Modules -import GhcModExe.PkgDoc -import GhcModExe.Test -import Language.Haskell.GhcMod.Cradle -import Language.Haskell.GhcMod.FileMapping -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Output -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.Types +import GhcMod.Exe.Boot +import GhcMod.Exe.Browse +import GhcMod.Exe.CaseSplit +import GhcMod.Exe.Check +import GhcMod.Exe.Debug +import GhcMod.Exe.FillSig +import GhcMod.Exe.Find +import GhcMod.Exe.Flag +import GhcMod.Exe.Info +import GhcMod.Exe.Lang +import GhcMod.Exe.Lint +import GhcMod.Exe.Modules +import GhcMod.Exe.PkgDoc +import GhcMod.Exe.Test +import GhcMod.Cradle +import GhcMod.FileMapping +import GhcMod.Logging +import GhcMod.Monad +import GhcMod.Output +import GhcMod.Target +import GhcMod.Types diff --git a/GhcModExe/Boot.hs b/GhcMod/Exe/Boot.hs similarity index 69% rename from GhcModExe/Boot.hs rename to GhcMod/Exe/Boot.hs index 35c43d3..4316259 100644 --- a/GhcModExe/Boot.hs +++ b/GhcMod/Exe/Boot.hs @@ -1,14 +1,14 @@ -module GhcModExe.Boot where +module GhcMod.Exe.Boot where import Control.Applicative import Prelude -import GhcModExe.Browse -import GhcModExe.Flag -import GhcModExe.Lang -import GhcModExe.Modules -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Types (defaultBrowseOpts) +import GhcMod.Exe.Browse +import GhcMod.Exe.Flag +import GhcMod.Exe.Lang +import GhcMod.Exe.Modules +import GhcMod.Monad +import GhcMod.Types (defaultBrowseOpts) -- | Printing necessary information for front-end booting. boot :: IOish m => GhcModT m String diff --git a/GhcModExe/Browse.hs b/GhcMod/Exe/Browse.hs similarity index 95% rename from GhcModExe/Browse.hs rename to GhcMod/Exe/Browse.hs index d09666b..069750b 100644 --- a/GhcModExe/Browse.hs +++ b/GhcMod/Exe/Browse.hs @@ -1,5 +1,5 @@ {-# LANGUAGE CPP #-} -module GhcModExe.Browse ( +module GhcMod.Exe.Browse ( browse, BrowseOpts(..) ) where @@ -14,12 +14,12 @@ import FastString import GHC import HscTypes import qualified GHC as G -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Doc (showPage, styleUnqualified) -import Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Logging +import GhcMod.Convert +import GhcMod.Doc (showPage, styleUnqualified) +import GhcMod.Gap as Gap +import GhcMod.Types +import GhcMod.Monad +import GhcMod.Logging import Name (getOccString) import Outputable import TyCon (isAlgTyCon) diff --git a/GhcModExe/CaseSplit.hs b/GhcMod/Exe/CaseSplit.hs similarity index 95% rename from GhcModExe/CaseSplit.hs rename to GhcMod/Exe/CaseSplit.hs index 02562aa..d866fb6 100644 --- a/GhcModExe/CaseSplit.hs +++ b/GhcMod/Exe/CaseSplit.hs @@ -1,6 +1,6 @@ {-# LANGUAGE CPP #-} -module GhcModExe.CaseSplit ( +module GhcMod.Exe.CaseSplit ( splits ) where @@ -19,16 +19,16 @@ import qualified TyCon as Ty import qualified Type as Ty import Exception -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.DynFlags -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.SrcUtils -import Language.Haskell.GhcMod.Doc -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils (withMappedFile) -import Language.Haskell.GhcMod.FileMapping (fileModSummaryWithMapping) +import GhcMod.Convert +import GhcMod.DynFlags +import qualified GhcMod.Gap as Gap +import GhcMod.Monad +import GhcMod.SrcUtils +import GhcMod.Doc +import GhcMod.Logging +import GhcMod.Types +import GhcMod.Utils (withMappedFile) +import GhcMod.FileMapping (fileModSummaryWithMapping) import Control.DeepSeq ---------------------------------------------------------------- diff --git a/GhcModExe/Check.hs b/GhcMod/Exe/Check.hs similarity index 88% rename from GhcModExe/Check.hs rename to GhcMod/Exe/Check.hs index dcb6868..00f2c0f 100644 --- a/GhcModExe/Check.hs +++ b/GhcMod/Exe/Check.hs @@ -1,4 +1,4 @@ -module GhcModExe.Check ( +module GhcMod.Exe.Check ( checkSyntax , check , expandTemplate @@ -7,10 +7,10 @@ module GhcModExe.Check ( import Control.Applicative import Prelude -import Language.Haskell.GhcMod.DynFlags -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Logger -import Language.Haskell.GhcMod.Monad +import GhcMod.DynFlags +import qualified GhcMod.Gap as Gap +import GhcMod.Logger +import GhcMod.Monad ---------------------------------------------------------------- diff --git a/GhcModExe/Debug.hs b/GhcMod/Exe/Debug.hs similarity index 93% rename from GhcModExe/Debug.hs rename to GhcMod/Exe/Debug.hs index 39f63e5..2ba7ac5 100644 --- a/GhcModExe/Debug.hs +++ b/GhcMod/Exe/Debug.hs @@ -1,4 +1,4 @@ -module GhcModExe.Debug (debugInfo, rootInfo, componentInfo) where +module GhcMod.Exe.Debug (debugInfo, rootInfo, componentInfo) where import Control.Arrow (first) import Control.Applicative @@ -11,15 +11,15 @@ import Data.Version import Data.List.Split import System.Directory -import GhcModExe.Internal -import Language.Haskell.GhcMod.Cradle -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Output -import Language.Haskell.GhcMod.Pretty -import Language.Haskell.GhcMod.Stack -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils +import GhcMod.Exe.Internal +import GhcMod.Cradle +import GhcMod.Monad +import GhcMod.Output +import GhcMod.Pretty +import GhcMod.Stack +import GhcMod.Target +import GhcMod.Types +import GhcMod.Utils import Paths_ghc_mod (version) diff --git a/GhcModExe/FillSig.hs b/GhcMod/Exe/FillSig.hs similarity index 97% rename from GhcModExe/FillSig.hs rename to GhcMod/Exe/FillSig.hs index 0172a3b..236f1dc 100644 --- a/GhcModExe/FillSig.hs +++ b/GhcMod/Exe/FillSig.hs @@ -1,7 +1,7 @@ {-# LANGUAGE CPP, MultiParamTypeClasses, FunctionalDependencies #-} {-# LANGUAGE FlexibleInstances #-} -module GhcModExe.FillSig ( +module GhcMod.Exe.FillSig ( sig , refine , auto @@ -30,16 +30,16 @@ import qualified HsPat as Ty import qualified Language.Haskell.Exts as HE import Djinn.GHC -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.DynFlags -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.SrcUtils -import Language.Haskell.GhcMod.Logging (gmLog) -import Language.Haskell.GhcMod.Pretty (showToDoc) -import Language.Haskell.GhcMod.Doc -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.FileMapping (fileModSummaryWithMapping) +import qualified GhcMod.Gap as Gap +import GhcMod.Convert +import GhcMod.DynFlags +import GhcMod.Monad +import GhcMod.SrcUtils +import GhcMod.Logging (gmLog) +import GhcMod.Pretty (showToDoc) +import GhcMod.Doc +import GhcMod.Types +import GhcMod.FileMapping (fileModSummaryWithMapping) #if __GLASGOW_HASKELL__ >= 710 import GHC (unLoc) diff --git a/GhcModExe/Find.hs b/GhcMod/Exe/Find.hs similarity index 94% rename from GhcModExe/Find.hs rename to GhcMod/Exe/Find.hs index 3e0a7fd..17c6190 100644 --- a/GhcModExe/Find.hs +++ b/GhcMod/Exe/Find.hs @@ -1,6 +1,6 @@ {-# LANGUAGE CPP, BangPatterns, TupleSections, DeriveGeneric #-} -module GhcModExe.Find +module GhcMod.Exe.Find ( Symbol , SymbolDb , loadSymbolDb @@ -22,14 +22,14 @@ import OccName import HscTypes import Exception -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Gap -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Output -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils -import Language.Haskell.GhcMod.World -import Language.Haskell.GhcMod.LightGhc +import GhcMod.Convert +import GhcMod.Gap +import GhcMod.Monad +import GhcMod.Output +import GhcMod.Types +import GhcMod.Utils +import GhcMod.World +import GhcMod.LightGhc import Control.Applicative import Control.DeepSeq @@ -53,7 +53,7 @@ import Data.Map (Map) import qualified Data.Map as M import Data.Set (Set) import qualified Data.Set as S -import Language.Haskell.GhcMod.PathsAndFiles +import GhcMod.PathsAndFiles import System.Directory import Prelude diff --git a/GhcMod/Exe/Flag.hs b/GhcMod/Exe/Flag.hs new file mode 100644 index 0000000..9384dd6 --- /dev/null +++ b/GhcMod/Exe/Flag.hs @@ -0,0 +1,9 @@ +module GhcMod.Exe.Flag where + +import qualified GhcMod.Gap as Gap +import GhcMod.Convert +import GhcMod.Monad + +-- | Listing of GHC flags, same as @ghc@\'s @--show-options@ with @ghc >= 7.10@. +flags :: IOish m => GhcModT m String +flags = convert' Gap.ghcCmdOptions diff --git a/GhcModExe/Info.hs b/GhcMod/Exe/Info.hs similarity index 81% rename from GhcModExe/Info.hs rename to GhcMod/Exe/Info.hs index 0b635ae..0021936 100644 --- a/GhcModExe/Info.hs +++ b/GhcMod/Exe/Info.hs @@ -1,4 +1,4 @@ -module GhcModExe.Info ( +module GhcMod.Exe.Info ( info , types ) where @@ -11,17 +11,17 @@ import GHC (GhcMonad, SrcSpan) import Prelude import qualified GHC as G -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Doc -import Language.Haskell.GhcMod.DynFlags -import Language.Haskell.GhcMod.Gap -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.SrcUtils -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils (mkRevRedirMapFunc) -import Language.Haskell.GhcMod.FileMapping (fileModSummaryWithMapping) +import qualified GhcMod.Gap as Gap +import GhcMod.Convert +import GhcMod.Doc +import GhcMod.DynFlags +import GhcMod.Gap +import GhcMod.Logging +import GhcMod.Monad +import GhcMod.SrcUtils +import GhcMod.Types +import GhcMod.Utils (mkRevRedirMapFunc) +import GhcMod.FileMapping (fileModSummaryWithMapping) ---------------------------------------------------------------- diff --git a/GhcModExe/Internal.hs b/GhcMod/Exe/Internal.hs similarity index 68% rename from GhcModExe/Internal.hs rename to GhcMod/Exe/Internal.hs index d310690..930b22b 100644 --- a/GhcModExe/Internal.hs +++ b/GhcMod/Exe/Internal.hs @@ -1,6 +1,6 @@ -- | Low level access to the ghc-mod library. -module GhcModExe.Internal ( +module GhcMod.Exe.Internal ( -- * Types GHCOption , IncludeDir @@ -51,22 +51,22 @@ module GhcModExe.Internal ( , GHandler(..) , gcatches -- * FileMapping - , module Language.Haskell.GhcMod.FileMapping + , module GhcMod.FileMapping ) where import GHC.Paths (libdir) -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.DynFlags -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Logger -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils -import Language.Haskell.GhcMod.World -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.FileMapping +import GhcMod.Target +import GhcMod.DynFlags +import GhcMod.Error +import GhcMod.Logger +import GhcMod.Logging +import GhcMod.Monad +import GhcMod.Types +import GhcMod.Utils +import GhcMod.World +import GhcMod.CabalHelper +import GhcMod.FileMapping -- | Obtaining the directory for ghc system libraries. ghcLibDir :: FilePath diff --git a/GhcModExe/Lang.hs b/GhcMod/Exe/Lang.hs similarity index 63% rename from GhcModExe/Lang.hs rename to GhcMod/Exe/Lang.hs index 0a5ac4b..3546c4a 100644 --- a/GhcModExe/Lang.hs +++ b/GhcMod/Exe/Lang.hs @@ -1,8 +1,8 @@ -module GhcModExe.Lang where +module GhcMod.Exe.Lang where import DynFlags (supportedLanguagesAndExtensions) -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Monad +import GhcMod.Convert +import GhcMod.Monad -- | Listing language extensions. diff --git a/GhcModExe/Lint.hs b/GhcMod/Exe/Lint.hs similarity index 77% rename from GhcModExe/Lint.hs rename to GhcMod/Exe/Lint.hs index 12237a9..c4a2d75 100644 --- a/GhcModExe/Lint.hs +++ b/GhcMod/Exe/Lint.hs @@ -1,14 +1,14 @@ -module GhcModExe.Lint where +module GhcMod.Exe.Lint where import Exception (ghandle) import Control.Exception (SomeException(..)) -import Language.Haskell.GhcMod.Logger (checkErrorPrefix) -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad +import GhcMod.Logger (checkErrorPrefix) +import GhcMod.Convert +import GhcMod.Types +import GhcMod.Monad import Language.Haskell.HLint3 -import Language.Haskell.GhcMod.Utils (withMappedFile) +import GhcMod.Utils (withMappedFile) import Language.Haskell.Exts.SrcLoc (SrcSpan(..)) -- | Checking syntax of a target file using hlint. diff --git a/GhcModExe/Modules.hs b/GhcMod/Exe/Modules.hs similarity index 78% rename from GhcModExe/Modules.hs rename to GhcMod/Exe/Modules.hs index 80abe7d..735bd8f 100644 --- a/GhcModExe/Modules.hs +++ b/GhcMod/Exe/Modules.hs @@ -1,11 +1,11 @@ -module GhcModExe.Modules (modules) where +module GhcMod.Exe.Modules (modules) where import Control.Arrow import Data.List -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Gap ( listVisibleModuleNames +import GhcMod.Convert +import GhcMod.Types +import GhcMod.Monad +import GhcMod.Gap ( listVisibleModuleNames , lookupModulePackageInAllPackages ) diff --git a/GhcModExe/PkgDoc.hs b/GhcMod/Exe/PkgDoc.hs similarity index 80% rename from GhcModExe/PkgDoc.hs rename to GhcMod/Exe/PkgDoc.hs index d10d2d8..4d521fd 100644 --- a/GhcModExe/PkgDoc.hs +++ b/GhcMod/Exe/PkgDoc.hs @@ -1,9 +1,9 @@ -module GhcModExe.PkgDoc (pkgDoc) where +module GhcMod.Exe.PkgDoc (pkgDoc) where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.GhcPkg -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Output +import GhcMod.Types +import GhcMod.GhcPkg +import GhcMod.Monad +import GhcMod.Output import Control.Applicative import Prelude diff --git a/GhcModExe/Test.hs b/GhcMod/Exe/Test.hs similarity index 88% rename from GhcModExe/Test.hs rename to GhcMod/Exe/Test.hs index be127e9..96eb01c 100644 --- a/GhcModExe/Test.hs +++ b/GhcMod/Exe/Test.hs @@ -1,4 +1,4 @@ -module GhcModExe.Test where +module GhcMod.Exe.Test where import Control.Applicative import Data.List @@ -6,9 +6,9 @@ import System.FilePath import System.Directory import Prelude -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.DynFlags +import GhcMod.Types +import GhcMod.Monad +import GhcMod.DynFlags import GHC import GHC.Exception diff --git a/GhcModExe/Flag.hs b/GhcModExe/Flag.hs deleted file mode 100644 index 1a09f77..0000000 --- a/GhcModExe/Flag.hs +++ /dev/null @@ -1,9 +0,0 @@ -module GhcModExe.Flag where - -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Monad - --- | Listing of GHC flags, same as @ghc@\'s @--show-options@ with @ghc >= 7.10@. -flags :: IOish m => GhcModT m String -flags = convert' Gap.ghcCmdOptions diff --git a/bench/Bench.hs b/bench/Bench.hs index 1880492..542fa4c 100644 --- a/bench/Bench.hs +++ b/bench/Bench.hs @@ -1,7 +1,7 @@ import Criterion.Main -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Types +import GhcMod.Target +import GhcMod.Monad +import GhcMod.Types import Dir import System.IO.Temp import System.Process hiding (env) diff --git a/core/Language/Haskell/GhcMod/CabalHelper.hs b/core/GhcMod/CabalHelper.hs similarity index 96% rename from core/Language/Haskell/GhcMod/CabalHelper.hs rename to core/GhcMod/CabalHelper.hs index cb09569..4265739 100644 --- a/core/Language/Haskell/GhcMod/CabalHelper.hs +++ b/core/GhcMod/CabalHelper.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE CPP #-} -module Language.Haskell.GhcMod.CabalHelper +module GhcMod.CabalHelper ( getComponents , getGhcMergedPkgOptions , getCabalPackageDbStack @@ -34,15 +34,15 @@ import Data.Binary (Binary) import Data.Traversable import Distribution.Helper hiding (Programs(..)) import qualified Distribution.Helper as CH -import qualified Language.Haskell.GhcMod.Types as T -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Utils -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Output -import Language.Haskell.GhcMod.CustomPackageDb -import Language.Haskell.GhcMod.Stack +import qualified GhcMod.Types as T +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Utils +import GhcMod.PathsAndFiles +import GhcMod.Logging +import GhcMod.Output +import GhcMod.CustomPackageDb +import GhcMod.Stack import System.FilePath import System.Process import System.Exit diff --git a/core/Language/Haskell/GhcMod/Caching.hs b/core/GhcMod/Caching.hs similarity index 94% rename from core/Language/Haskell/GhcMod/Caching.hs rename to core/GhcMod/Caching.hs index c8cdb05..2f58929 100644 --- a/core/Language/Haskell/GhcMod/Caching.hs +++ b/core/GhcMod/Caching.hs @@ -14,9 +14,9 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . {-# LANGUAGE CPP, OverloadedStrings #-} -module Language.Haskell.GhcMod.Caching ( - module Language.Haskell.GhcMod.Caching - , module Language.Haskell.GhcMod.Caching.Types +module GhcMod.Caching ( + module GhcMod.Caching + , module GhcMod.Caching.Types ) where import Control.Arrow (first) @@ -38,9 +38,9 @@ import Utils (TimedFile(..), timeMaybe, mightExist) import Paths_ghc_mod (version) import Prelude -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Caching.Types -import Language.Haskell.GhcMod.Logging +import GhcMod.Monad.Types +import GhcMod.Caching.Types +import GhcMod.Logging -- | Cache a MonadIO action with proper invalidation. cached :: forall m a d. (Gm m, MonadIO m, Binary a, Eq d, Binary d, Show d) diff --git a/core/Language/Haskell/GhcMod/Caching/Types.hs b/core/GhcMod/Caching/Types.hs similarity index 97% rename from core/Language/Haskell/GhcMod/Caching/Types.hs rename to core/GhcMod/Caching/Types.hs index 501eae2..4a8a813 100644 --- a/core/Language/Haskell/GhcMod/Caching/Types.hs +++ b/core/GhcMod/Caching/Types.hs @@ -13,7 +13,7 @@ -- -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.Caching.Types where +module GhcMod.Caching.Types where import Utils import Data.Label diff --git a/core/Language/Haskell/GhcMod/Convert.hs b/core/GhcMod/Convert.hs similarity index 96% rename from core/Language/Haskell/GhcMod/Convert.hs rename to core/GhcMod/Convert.hs index fa266d2..f33509e 100644 --- a/core/Language/Haskell/GhcMod/Convert.hs +++ b/core/GhcMod/Convert.hs @@ -1,9 +1,9 @@ {-# LANGUAGE CPP, FlexibleInstances, FlexibleContexts #-} -module Language.Haskell.GhcMod.Convert (convert, convert', emptyResult, whenFound, whenFound') where +module GhcMod.Convert (convert, convert', emptyResult, whenFound, whenFound') where -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Types import Control.Applicative import Prelude diff --git a/core/Language/Haskell/GhcMod/Cradle.hs b/core/GhcMod/Cradle.hs similarity index 95% rename from core/Language/Haskell/GhcMod/Cradle.hs rename to core/GhcMod/Cradle.hs index b4e499b..9226fd5 100644 --- a/core/Language/Haskell/GhcMod/Cradle.hs +++ b/core/GhcMod/Cradle.hs @@ -1,5 +1,5 @@ {-# LANGUAGE CPP #-} -module Language.Haskell.GhcMod.Cradle +module GhcMod.Cradle ( findCradle , findCradle' , findCradleNoLog @@ -10,13 +10,13 @@ module Language.Haskell.GhcMod.Cradle , plainCradle ) where -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils -import Language.Haskell.GhcMod.Stack -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Error +import GhcMod.PathsAndFiles +import GhcMod.Monad.Types +import GhcMod.Types +import GhcMod.Utils +import GhcMod.Stack +import GhcMod.Logging +import GhcMod.Error import Safe import Control.Applicative diff --git a/core/Language/Haskell/GhcMod/CustomPackageDb.hs b/core/GhcMod/CustomPackageDb.hs similarity index 88% rename from core/Language/Haskell/GhcMod/CustomPackageDb.hs rename to core/GhcMod/CustomPackageDb.hs index 8fc78e3..8f6c38c 100644 --- a/core/Language/Haskell/GhcMod/CustomPackageDb.hs +++ b/core/GhcMod/CustomPackageDb.hs @@ -13,16 +13,16 @@ -- -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.CustomPackageDb where +module GhcMod.CustomPackageDb where import Control.Applicative import Control.Monad import Control.Category ((.)) import Data.Maybe import Data.Traversable -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.PathsAndFiles +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.PathsAndFiles import Prelude hiding ((.)) parseCustomPackageDb :: String -> [GhcPkgDb] diff --git a/core/Language/Haskell/GhcMod/DebugLogger.hs b/core/GhcMod/DebugLogger.hs similarity index 97% rename from core/Language/Haskell/GhcMod/DebugLogger.hs rename to core/GhcMod/DebugLogger.hs index 780dcd6..6e9dfa8 100644 --- a/core/Language/Haskell/GhcMod/DebugLogger.hs +++ b/core/GhcMod/DebugLogger.hs @@ -14,7 +14,7 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . {-# LANGUAGE CPP, RankNTypes #-} -module Language.Haskell.GhcMod.DebugLogger where +module GhcMod.DebugLogger where -- (c) The University of Glasgow 2005 -- @@ -57,8 +57,8 @@ import Outputable (SDoc, PprStyle, runSDoc, initSDocContext, blankLine) import qualified Outputable import ErrUtils -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Gap +import GhcMod.Error +import GhcMod.Gap import Prelude debugLogAction :: (String -> IO ()) -> GmLogAction diff --git a/core/Language/Haskell/GhcMod/Doc.hs b/core/GhcMod/Doc.hs similarity index 83% rename from core/Language/Haskell/GhcMod/Doc.hs rename to core/GhcMod/Doc.hs index 7914e2e..005eaf1 100644 --- a/core/Language/Haskell/GhcMod/Doc.hs +++ b/core/GhcMod/Doc.hs @@ -1,7 +1,7 @@ -module Language.Haskell.GhcMod.Doc where +module GhcMod.Doc where import GHC -import Language.Haskell.GhcMod.Gap (withStyle, showDocWith) +import GhcMod.Gap (withStyle, showDocWith) import Outputable import Pretty (Mode(..)) diff --git a/core/Language/Haskell/GhcMod/DynFlags.hs b/core/GhcMod/DynFlags.hs similarity index 93% rename from core/Language/Haskell/GhcMod/DynFlags.hs rename to core/GhcMod/DynFlags.hs index a68a050..77f213d 100644 --- a/core/Language/Haskell/GhcMod/DynFlags.hs +++ b/core/GhcMod/DynFlags.hs @@ -1,16 +1,16 @@ {-# LANGUAGE TemplateHaskell #-} -module Language.Haskell.GhcMod.DynFlags where +module GhcMod.DynFlags where import Control.Applicative import Control.Monad import GHC import qualified GHC as G import GHC.Paths (libdir) -import qualified Language.Haskell.GhcMod.Gap as Gap -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.DebugLogger -import Language.Haskell.GhcMod.DynFlagsTH +import qualified GhcMod.Gap as Gap +import GhcMod.Types +import GhcMod.DebugLogger +import GhcMod.DynFlagsTH import System.IO.Unsafe (unsafePerformIO) import Prelude diff --git a/core/Language/Haskell/GhcMod/DynFlagsTH.hs b/core/GhcMod/DynFlagsTH.hs similarity index 99% rename from core/Language/Haskell/GhcMod/DynFlagsTH.hs rename to core/GhcMod/DynFlagsTH.hs index f5a1c01..9085707 100644 --- a/core/Language/Haskell/GhcMod/DynFlagsTH.hs +++ b/core/GhcMod/DynFlagsTH.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE CPP, TemplateHaskell #-} -module Language.Haskell.GhcMod.DynFlagsTH where +module GhcMod.DynFlagsTH where import Language.Haskell.TH import Language.Haskell.TH.Syntax diff --git a/core/Language/Haskell/GhcMod/Error.hs b/core/GhcMod/Error.hs similarity index 98% rename from core/Language/Haskell/GhcMod/Error.hs rename to core/GhcMod/Error.hs index bf60962..18e5fc8 100644 --- a/core/Language/Haskell/GhcMod/Error.hs +++ b/core/GhcMod/Error.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE ExistentialQuantification #-} -module Language.Haskell.GhcMod.Error ( +module GhcMod.Error ( GhcModError(..) , GmError , gmeDoc @@ -47,8 +47,8 @@ import Pretty import Config (cProjectVersion, cHostPlatformString) import Paths_ghc_mod (version) -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Pretty +import GhcMod.Types +import GhcMod.Pretty type GmError m = MonadError GhcModError m diff --git a/core/Language/Haskell/GhcMod/FileMapping.hs b/core/GhcMod/FileMapping.hs similarity index 93% rename from core/Language/Haskell/GhcMod/FileMapping.hs rename to core/GhcMod/FileMapping.hs index 4655605..e05a540 100644 --- a/core/Language/Haskell/GhcMod/FileMapping.hs +++ b/core/GhcMod/FileMapping.hs @@ -1,4 +1,4 @@ -module Language.Haskell.GhcMod.FileMapping +module GhcMod.FileMapping ( loadMappedFile , loadMappedFileSource , unloadMappedFile @@ -6,11 +6,11 @@ module Language.Haskell.GhcMod.FileMapping , fileModSummaryWithMapping ) where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Gap -import Language.Haskell.GhcMod.HomeModuleGraph -import Language.Haskell.GhcMod.Utils +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Gap +import GhcMod.HomeModuleGraph +import GhcMod.Utils import System.IO import System.FilePath diff --git a/core/Language/Haskell/GhcMod/Gap.hs b/core/GhcMod/Gap.hs similarity index 99% rename from core/Language/Haskell/GhcMod/Gap.hs rename to core/GhcMod/Gap.hs index 13d0246..728a04c 100644 --- a/core/Language/Haskell/GhcMod/Gap.hs +++ b/core/GhcMod/Gap.hs @@ -1,7 +1,7 @@ {-# LANGUAGE TypeSynonymInstances, FlexibleInstances, CPP, ScopedTypeVariables, RankNTypes #-} -module Language.Haskell.GhcMod.Gap ( - Language.Haskell.GhcMod.Gap.ClsInst +module GhcMod.Gap ( + GhcMod.Gap.ClsInst , mkTarget , withStyle , GmLogAction @@ -44,7 +44,7 @@ module Language.Haskell.GhcMod.Gap ( , listVisibleModuleNames , listVisibleModules , lookupModulePackageInAllPackages - , Language.Haskell.GhcMod.Gap.isSynTyCon + , GhcMod.Gap.isSynTyCon , parseModuleHeader , mkErrStyle' , everythingStagedWithContext @@ -139,7 +139,7 @@ import Packages import Data.Generics (GenericQ, extQ, gmapQ) import GHC.SYB.Utils (Stage(..)) -import Language.Haskell.GhcMod.Types (Expression(..)) +import GhcMod.Types (Expression(..)) import Prelude ---------------------------------------------------------------- diff --git a/core/Language/Haskell/GhcMod/GhcPkg.hs b/core/GhcMod/GhcPkg.hs similarity index 92% rename from core/Language/Haskell/GhcMod/GhcPkg.hs rename to core/GhcMod/GhcPkg.hs index 86ab83b..746b2ea 100644 --- a/core/Language/Haskell/GhcMod/GhcPkg.hs +++ b/core/GhcMod/GhcPkg.hs @@ -1,5 +1,5 @@ {-# LANGUAGE BangPatterns, ScopedTypeVariables, TupleSections #-} -module Language.Haskell.GhcMod.GhcPkg ( +module GhcMod.GhcPkg ( ghcPkgDbOpt , ghcPkgDbStackOpts , ghcDbStackOpts @@ -18,12 +18,12 @@ import System.Directory (doesDirectoryExist, getAppUserDataDirectory) import System.FilePath (()) import Prelude -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.CustomPackageDb -import Language.Haskell.GhcMod.Stack +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.CabalHelper +import GhcMod.PathsAndFiles +import GhcMod.CustomPackageDb +import GhcMod.Stack ghcVersion :: Int ghcVersion = read cProjectVersionInt diff --git a/core/Language/Haskell/GhcMod/HomeModuleGraph.hs b/core/GhcMod/HomeModuleGraph.hs similarity index 96% rename from core/Language/Haskell/GhcMod/HomeModuleGraph.hs rename to core/GhcMod/HomeModuleGraph.hs index 7ed7b01..cda8261 100644 --- a/core/Language/Haskell/GhcMod/HomeModuleGraph.hs +++ b/core/GhcMod/HomeModuleGraph.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE ScopedTypeVariables, RecordWildCards #-} -module Language.Haskell.GhcMod.HomeModuleGraph ( +module GhcMod.HomeModuleGraph ( GmModuleGraph(..) , ModulePath(..) , mkFileMap @@ -58,12 +58,12 @@ import System.Directory import System.IO import Prelude -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Logger -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils (withMappedFile) -import Language.Haskell.GhcMod.Gap (parseModuleHeader) +import GhcMod.Logging +import GhcMod.Logger +import GhcMod.Monad.Types +import GhcMod.Types +import GhcMod.Utils (withMappedFile) +import GhcMod.Gap (parseModuleHeader) -- | Turn module graph into a graphviz dot file -- diff --git a/core/Language/Haskell/GhcMod/LightGhc.hs b/core/GhcMod/LightGhc.hs similarity index 89% rename from core/Language/Haskell/GhcMod/LightGhc.hs rename to core/GhcMod/LightGhc.hs index 8978991..3be80e0 100644 --- a/core/Language/Haskell/GhcMod/LightGhc.hs +++ b/core/GhcMod/LightGhc.hs @@ -1,4 +1,4 @@ -module Language.Haskell.GhcMod.LightGhc where +module GhcMod.LightGhc where import Control.Monad import Control.Monad.Reader (runReaderT) @@ -12,10 +12,10 @@ import DynFlags import HscMain import HscTypes -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.DynFlags -import qualified Language.Haskell.GhcMod.Gap as Gap +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.DynFlags +import qualified GhcMod.Gap as Gap -- We have to be more careful about tearing down 'HscEnv's since GHC 8 added an -- out of process GHCI server which has to be shutdown. diff --git a/core/Language/Haskell/GhcMod/Logger.hs b/core/GhcMod/Logger.hs similarity index 93% rename from core/Language/Haskell/GhcMod/Logger.hs rename to core/GhcMod/Logger.hs index 6c14d5e..3ccf89b 100644 --- a/core/Language/Haskell/GhcMod/Logger.hs +++ b/core/GhcMod/Logger.hs @@ -1,6 +1,6 @@ {-# LANGUAGE CPP, RankNTypes #-} -module Language.Haskell.GhcMod.Logger ( +module GhcMod.Logger ( withLogger , withLogger' , checkErrorPrefix @@ -27,14 +27,14 @@ import Bag import SrcLoc import FastString -import Language.Haskell.GhcMod.Convert -import Language.Haskell.GhcMod.Doc (showPage) -import Language.Haskell.GhcMod.DynFlags (withDynFlags) -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Pretty -import Language.Haskell.GhcMod.Utils (mkRevRedirMapFunc) -import qualified Language.Haskell.GhcMod.Gap as Gap +import GhcMod.Convert +import GhcMod.Doc (showPage) +import GhcMod.DynFlags (withDynFlags) +import GhcMod.Monad.Types +import GhcMod.Error +import GhcMod.Pretty +import GhcMod.Utils (mkRevRedirMapFunc) +import qualified GhcMod.Gap as Gap import Prelude type Builder = [String] -> [String] diff --git a/core/Language/Haskell/GhcMod/Logging.hs b/core/GhcMod/Logging.hs similarity index 92% rename from core/Language/Haskell/GhcMod/Logging.hs rename to core/GhcMod/Logging.hs index a6cfaff..930a56b 100644 --- a/core/Language/Haskell/GhcMod/Logging.hs +++ b/core/GhcMod/Logging.hs @@ -16,9 +16,9 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} -module Language.Haskell.GhcMod.Logging ( - module Language.Haskell.GhcMod.Logging - , module Language.Haskell.GhcMod.Pretty +module GhcMod.Logging ( + module GhcMod.Logging + , module GhcMod.Pretty , GmLogLevel(..) , module Data.Monoid , module Pretty @@ -37,10 +37,10 @@ import Prelude import Pretty hiding (style, (<>)) -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Pretty -import Language.Haskell.GhcMod.Output +import GhcMod.Monad.Types +import GhcMod.Types +import GhcMod.Pretty +import GhcMod.Output gmSetLogLevel :: GmLog m => GmLogLevel -> m () gmSetLogLevel level = diff --git a/core/Language/Haskell/GhcMod/Monad.hs b/core/GhcMod/Monad.hs similarity index 92% rename from core/Language/Haskell/GhcMod/Monad.hs rename to core/GhcMod/Monad.hs index 8f44db8..83d22b6 100644 --- a/core/Language/Haskell/GhcMod/Monad.hs +++ b/core/GhcMod/Monad.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE CPP #-} -module Language.Haskell.GhcMod.Monad ( +module GhcMod.Monad ( runGmOutT , runGmOutT' , runGhcModT @@ -27,16 +27,16 @@ module Language.Haskell.GhcMod.Monad ( , runGmPkgGhc , withGhcModEnv , withGhcModEnv' - , module Language.Haskell.GhcMod.Monad.Types + , module GhcMod.Monad.Types ) where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Cradle -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.Output +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Error +import GhcMod.Logging +import GhcMod.Cradle +import GhcMod.Target +import GhcMod.Output import Control.Arrow (first) import Control.Applicative diff --git a/core/Language/Haskell/GhcMod/Monad/Compat.hs_h b/core/GhcMod/Monad/Compat.hs_h similarity index 100% rename from core/Language/Haskell/GhcMod/Monad/Compat.hs_h rename to core/GhcMod/Monad/Compat.hs_h diff --git a/core/Language/Haskell/GhcMod/Monad/Env.hs b/core/GhcMod/Monad/Env.hs similarity index 94% rename from core/Language/Haskell/GhcMod/Monad/Env.hs rename to core/GhcMod/Monad/Env.hs index 23b42be..79db698 100644 --- a/core/Language/Haskell/GhcMod/Monad/Env.hs +++ b/core/GhcMod/Monad/Env.hs @@ -17,10 +17,10 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-} {-# LANGUAGE FlexibleInstances, UndecidableInstances #-} -module Language.Haskell.GhcMod.Monad.Env where +module GhcMod.Monad.Env where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Newtypes +import GhcMod.Types +import GhcMod.Monad.Newtypes import Control.Monad import Control.Monad.Trans.Journal (JournalT) diff --git a/core/Language/Haskell/GhcMod/Monad/Log.hs b/core/GhcMod/Monad/Log.hs similarity index 94% rename from core/Language/Haskell/GhcMod/Monad/Log.hs rename to core/GhcMod/Monad/Log.hs index f353084..5e21375 100644 --- a/core/Language/Haskell/GhcMod/Monad/Log.hs +++ b/core/GhcMod/Monad/Log.hs @@ -17,10 +17,10 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-} {-# LANGUAGE FlexibleInstances, UndecidableInstances #-} -module Language.Haskell.GhcMod.Monad.Log where +module GhcMod.Monad.Log where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Newtypes +import GhcMod.Types +import GhcMod.Monad.Newtypes import Control.Monad import Control.Monad.Trans.Journal (JournalT) diff --git a/core/Language/Haskell/GhcMod/Monad/Newtypes.hs b/core/GhcMod/Monad/Newtypes.hs similarity index 98% rename from core/Language/Haskell/GhcMod/Monad/Newtypes.hs rename to core/GhcMod/Monad/Newtypes.hs index 90a6b26..b9a070f 100644 --- a/core/Language/Haskell/GhcMod/Monad/Newtypes.hs +++ b/core/GhcMod/Monad/Newtypes.hs @@ -18,11 +18,11 @@ {-# LANGUAGE MultiParamTypeClasses, TypeFamilies, UndecidableInstances #-} {-# LANGUAGE RankNTypes, FlexibleInstances #-} -module Language.Haskell.GhcMod.Monad.Newtypes where +module GhcMod.Monad.Newtypes where #include "Compat.hs_h" -import Language.Haskell.GhcMod.Types +import GhcMod.Types import GHC diff --git a/core/Language/Haskell/GhcMod/Monad/Orphans.hs b/core/GhcMod/Monad/Orphans.hs similarity index 95% rename from core/Language/Haskell/GhcMod/Monad/Orphans.hs rename to core/GhcMod/Monad/Orphans.hs index 18fe9f5..0c9e7fd 100644 --- a/core/Language/Haskell/GhcMod/Monad/Orphans.hs +++ b/core/GhcMod/Monad/Orphans.hs @@ -18,12 +18,12 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Language.Haskell.GhcMod.Monad.Orphans where +module GhcMod.Monad.Orphans where #include "Compat.hs_h" -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Newtypes +import GhcMod.Types +import GhcMod.Monad.Newtypes #if DIFFERENT_MONADIO import qualified MonadUtils as GHC (MonadIO(..)) diff --git a/core/Language/Haskell/GhcMod/Monad/Out.hs b/core/GhcMod/Monad/Out.hs similarity index 92% rename from core/Language/Haskell/GhcMod/Monad/Out.hs rename to core/GhcMod/Monad/Out.hs index d372f9f..6024f9d 100644 --- a/core/Language/Haskell/GhcMod/Monad/Out.hs +++ b/core/GhcMod/Monad/Out.hs @@ -17,10 +17,10 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-} {-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-} -module Language.Haskell.GhcMod.Monad.Out where +module GhcMod.Monad.Out where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Newtypes +import GhcMod.Types +import GhcMod.Monad.Newtypes import Control.Monad import Control.Monad.State.Strict (StateT(..)) diff --git a/core/Language/Haskell/GhcMod/Monad/State.hs b/core/GhcMod/Monad/State.hs similarity index 94% rename from core/Language/Haskell/GhcMod/Monad/State.hs rename to core/GhcMod/Monad/State.hs index 5edcbe7..fdef21e 100644 --- a/core/Language/Haskell/GhcMod/Monad/State.hs +++ b/core/GhcMod/Monad/State.hs @@ -17,10 +17,10 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving #-} {-# LANGUAGE FlexibleInstances, UndecidableInstances #-} -module Language.Haskell.GhcMod.Monad.State where +module GhcMod.Monad.State where -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Newtypes +import GhcMod.Types +import GhcMod.Monad.Newtypes import Control.Monad import Control.Monad.State.Strict (StateT(..)) diff --git a/core/Language/Haskell/GhcMod/Monad/Types.hs b/core/GhcMod/Monad/Types.hs similarity index 95% rename from core/Language/Haskell/GhcMod/Monad/Types.hs rename to core/GhcMod/Monad/Types.hs index 416ee13..abb7a6f 100644 --- a/core/Language/Haskell/GhcMod/Monad/Types.hs +++ b/core/GhcMod/Monad/Types.hs @@ -20,7 +20,7 @@ {-# LANGUAGE StandaloneDeriving #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Language.Haskell.GhcMod.Monad.Types ( +module GhcMod.Monad.Types ( -- * Monad Types GhcModT , GmOutT(..) @@ -64,14 +64,14 @@ module Language.Haskell.GhcMod.Monad.Types ( #include "Compat.hs_h" -import Language.Haskell.GhcMod.Types +import GhcMod.Types -import Language.Haskell.GhcMod.Monad.Env -import Language.Haskell.GhcMod.Monad.State -import Language.Haskell.GhcMod.Monad.Log -import Language.Haskell.GhcMod.Monad.Out -import Language.Haskell.GhcMod.Monad.Newtypes -import Language.Haskell.GhcMod.Monad.Orphans () +import GhcMod.Monad.Env +import GhcMod.Monad.State +import GhcMod.Monad.Log +import GhcMod.Monad.Out +import GhcMod.Monad.Newtypes +import GhcMod.Monad.Orphans () import Safe diff --git a/core/Language/Haskell/GhcMod/Options/DocUtils.hs b/core/GhcMod/Options/DocUtils.hs similarity index 95% rename from core/Language/Haskell/GhcMod/Options/DocUtils.hs rename to core/GhcMod/Options/DocUtils.hs index 9fd846c..ab8add7 100644 --- a/core/Language/Haskell/GhcMod/Options/DocUtils.hs +++ b/core/GhcMod/Options/DocUtils.hs @@ -14,7 +14,7 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.Options.DocUtils ( +module GhcMod.Options.DocUtils ( ($$), ($$$), (<=>), diff --git a/core/Language/Haskell/GhcMod/Options/Help.hs b/core/GhcMod/Options/Help.hs similarity index 97% rename from core/Language/Haskell/GhcMod/Options/Help.hs rename to core/GhcMod/Options/Help.hs index 2ecc144..b23487c 100644 --- a/core/Language/Haskell/GhcMod/Options/Help.hs +++ b/core/GhcMod/Options/Help.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE OverloadedStrings, FlexibleInstances, GeneralizedNewtypeDeriving #-} -module Language.Haskell.GhcMod.Options.Help where +module GhcMod.Options.Help where import Options.Applicative import Options.Applicative.Help.Pretty (Doc) diff --git a/core/Language/Haskell/GhcMod/Options/Options.hs b/core/GhcMod/Options/Options.hs similarity index 96% rename from core/Language/Haskell/GhcMod/Options/Options.hs rename to core/GhcMod/Options/Options.hs index 34d6fe0..551f925 100644 --- a/core/Language/Haskell/GhcMod/Options/Options.hs +++ b/core/GhcMod/Options/Options.hs @@ -16,20 +16,20 @@ {-# LANGUAGE OverloadedStrings #-} {-# OPTIONS_GHC -fno-warn-unused-do-bind #-} -module Language.Haskell.GhcMod.Options.Options ( +module GhcMod.Options.Options ( globalArgSpec , parseCmdLineOptions ) where import Options.Applicative import Options.Applicative.Types -import Language.Haskell.GhcMod.Types +import GhcMod.Types import Control.Arrow import Data.Char (toUpper, toLower) import Data.List (intercalate) -import Language.Haskell.GhcMod.Read -import Language.Haskell.GhcMod.Options.DocUtils -import Language.Haskell.GhcMod.Options.Help +import GhcMod.Read +import GhcMod.Options.DocUtils +import GhcMod.Options.Help import Data.Monoid import Prelude diff --git a/core/Language/Haskell/GhcMod/Output.hs b/core/GhcMod/Output.hs similarity index 97% rename from core/Language/Haskell/GhcMod/Output.hs rename to core/GhcMod/Output.hs index 9a02b1c..0d39398 100644 --- a/core/Language/Haskell/GhcMod/Output.hs +++ b/core/GhcMod/Output.hs @@ -18,7 +18,7 @@ -- Copyright (c) The University of Glasgow 2004-2008 {-# LANGUAGE FlexibleInstances #-} -module Language.Haskell.GhcMod.Output ( +module GhcMod.Output ( gmPutStr , gmErrStr , gmPutStrLn @@ -53,9 +53,9 @@ import Pipes import Pipes.Lift import Prelude -import Language.Haskell.GhcMod.Types hiding (LineSeparator, MonadIO(..)) -import Language.Haskell.GhcMod.Monad.Types hiding (MonadIO(..)) -import Language.Haskell.GhcMod.Gap () +import GhcMod.Types hiding (LineSeparator, MonadIO(..)) +import GhcMod.Monad.Types hiding (MonadIO(..)) +import GhcMod.Gap () class ProcessOutput a where hGetContents' :: Handle -> IO a diff --git a/core/Language/Haskell/GhcMod/PathsAndFiles.hs b/core/GhcMod/PathsAndFiles.hs similarity index 96% rename from core/Language/Haskell/GhcMod/PathsAndFiles.hs rename to core/GhcMod/PathsAndFiles.hs index dcb982e..c55987c 100644 --- a/core/Language/Haskell/GhcMod/PathsAndFiles.hs +++ b/core/GhcMod/PathsAndFiles.hs @@ -14,9 +14,9 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.PathsAndFiles ( - module Language.Haskell.GhcMod.PathsAndFiles - , module Language.Haskell.GhcMod.Caching +module GhcMod.PathsAndFiles ( + module GhcMod.PathsAndFiles + , module GhcMod.Caching ) where import Config (cProjectVersion) @@ -34,9 +34,9 @@ import System.Directory import System.FilePath import System.Process -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Caching -import qualified Language.Haskell.GhcMod.Utils as U +import GhcMod.Types +import GhcMod.Caching +import qualified GhcMod.Utils as U import Utils (mightExist) import Prelude diff --git a/core/Language/Haskell/GhcMod/Pretty.hs b/core/GhcMod/Pretty.hs similarity index 94% rename from core/Language/Haskell/GhcMod/Pretty.hs rename to core/GhcMod/Pretty.hs index 35718a8..9f6145b 100644 --- a/core/Language/Haskell/GhcMod/Pretty.hs +++ b/core/GhcMod/Pretty.hs @@ -14,7 +14,7 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.Pretty +module GhcMod.Pretty ( renderGm , renderSDoc , gmComponentNameDoc @@ -35,9 +35,9 @@ import Pretty import GHC import Outputable (SDoc, withPprStyleDoc) -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Doc -import Language.Haskell.GhcMod.Gap (renderGm) +import GhcMod.Types +import GhcMod.Doc +import GhcMod.Gap (renderGm) renderSDoc :: GhcMonad m => SDoc -> m Doc renderSDoc sdoc = do diff --git a/core/Language/Haskell/GhcMod/Read.hs b/core/GhcMod/Read.hs similarity index 99% rename from core/Language/Haskell/GhcMod/Read.hs rename to core/GhcMod/Read.hs index 21b5b65..3297f51 100644 --- a/core/Language/Haskell/GhcMod/Read.hs +++ b/core/GhcMod/Read.hs @@ -1,4 +1,4 @@ -module Language.Haskell.GhcMod.Read where +module GhcMod.Read where import Text.Read (readPrec_to_S, readPrec, minPrec) import qualified Text.ParserCombinators.ReadP as P diff --git a/core/Language/Haskell/GhcMod/SrcUtils.hs b/core/GhcMod/SrcUtils.hs similarity index 97% rename from core/Language/Haskell/GhcMod/SrcUtils.hs rename to core/GhcMod/SrcUtils.hs index 5829fde..30999f3 100644 --- a/core/Language/Haskell/GhcMod/SrcUtils.hs +++ b/core/GhcMod/SrcUtils.hs @@ -2,7 +2,7 @@ {-# LANGUAGE CPP, TupleSections, FlexibleInstances, Rank2Types #-} {-# OPTIONS_GHC -fno-warn-orphans #-} -module Language.Haskell.GhcMod.SrcUtils where +module GhcMod.SrcUtils where import Control.Applicative import CoreUtils (exprType) @@ -17,9 +17,9 @@ import qualified Type as G import GHC.SYB.Utils import GhcMonad import qualified Language.Haskell.Exts as HE -import Language.Haskell.GhcMod.Doc -import Language.Haskell.GhcMod.Gap -import qualified Language.Haskell.GhcMod.Gap as Gap +import GhcMod.Doc +import GhcMod.Gap +import qualified GhcMod.Gap as Gap import OccName (OccName) import Outputable (PprStyle) import TcHsSyn (hsPatType) diff --git a/core/Language/Haskell/GhcMod/Stack.hs b/core/GhcMod/Stack.hs similarity index 92% rename from core/Language/Haskell/GhcMod/Stack.hs rename to core/GhcMod/Stack.hs index e733c88..0c0ada0 100644 --- a/core/Language/Haskell/GhcMod/Stack.hs +++ b/core/GhcMod/Stack.hs @@ -14,7 +14,7 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module Language.Haskell.GhcMod.Stack where +module GhcMod.Stack where import Safe import Control.Applicative @@ -30,12 +30,12 @@ import System.FilePath import System.Info.Extra import Exception -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Output -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Error -import qualified Language.Haskell.GhcMod.Utils as U +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Output +import GhcMod.Logging +import GhcMod.Error +import qualified GhcMod.Utils as U import Prelude patchStackPrograms :: (IOish m, GmOut m) => Cradle -> Programs -> m Programs diff --git a/core/Language/Haskell/GhcMod/Target.hs b/core/GhcMod/Target.hs similarity index 96% rename from core/Language/Haskell/GhcMod/Target.hs rename to core/GhcMod/Target.hs index f0eeeb6..1b61f9e 100644 --- a/core/Language/Haskell/GhcMod/Target.hs +++ b/core/GhcMod/Target.hs @@ -15,7 +15,7 @@ -- along with this program. If not, see . {-# LANGUAGE CPP, ViewPatterns, NamedFieldPuns, RankNTypes #-} -module Language.Haskell.GhcMod.Target where +module GhcMod.Target where import Control.Arrow import Control.Applicative @@ -30,20 +30,20 @@ import DynFlags import HscTypes import Pretty -import Language.Haskell.GhcMod.DynFlags -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.HomeModuleGraph -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.GhcPkg -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Utils as U -import Language.Haskell.GhcMod.FileMapping -import Language.Haskell.GhcMod.LightGhc -import Language.Haskell.GhcMod.CustomPackageDb -import Language.Haskell.GhcMod.Output +import GhcMod.DynFlags +import GhcMod.Monad.Types +import GhcMod.CabalHelper +import GhcMod.HomeModuleGraph +import GhcMod.PathsAndFiles +import GhcMod.GhcPkg +import GhcMod.Error +import GhcMod.Logging +import GhcMod.Types +import GhcMod.Utils as U +import GhcMod.FileMapping +import GhcMod.LightGhc +import GhcMod.CustomPackageDb +import GhcMod.Output import Safe import Data.Maybe diff --git a/core/Language/Haskell/GhcMod/Types.hs b/core/GhcMod/Types.hs similarity index 98% rename from core/Language/Haskell/GhcMod/Types.hs rename to core/GhcMod/Types.hs index 4836abb..7eccdac 100644 --- a/core/Language/Haskell/GhcMod/Types.hs +++ b/core/GhcMod/Types.hs @@ -2,8 +2,8 @@ StandaloneDeriving, DefaultSignatures, FlexibleInstances, TemplateHaskell, GeneralizedNewtypeDeriving #-} {-# OPTIONS_GHC -fno-warn-orphans -fno-warn-deprecations #-} -module Language.Haskell.GhcMod.Types ( - module Language.Haskell.GhcMod.Types +module GhcMod.Types ( + module GhcMod.Types , ModuleName , mkModuleName , moduleNameString @@ -40,7 +40,7 @@ import GHC.Generics import Pretty (Doc) import Prelude -import Language.Haskell.GhcMod.Caching.Types +import GhcMod.Caching.Types -- | A constraint alias (-XConstraintKinds) to make functions dealing with -- 'GhcModT' somewhat cleaner. diff --git a/core/Language/Haskell/GhcMod/Utils.hs b/core/GhcMod/Utils.hs similarity index 96% rename from core/Language/Haskell/GhcMod/Utils.hs rename to core/GhcMod/Utils.hs index c923750..38062b6 100644 --- a/core/Language/Haskell/GhcMod/Utils.hs +++ b/core/GhcMod/Utils.hs @@ -17,8 +17,8 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE DoAndIfThenElse #-} -module Language.Haskell.GhcMod.Utils ( - module Language.Haskell.GhcMod.Utils +module GhcMod.Utils ( + module GhcMod.Utils , module Utils , readProcess ) where @@ -30,9 +30,9 @@ import Data.Maybe (fromMaybe) import Data.Either (rights) import Data.List (inits) import Exception -import Language.Haskell.GhcMod.Error -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types +import GhcMod.Error +import GhcMod.Types +import GhcMod.Monad.Types import System.Directory import System.Environment import System.FilePath diff --git a/core/Language/Haskell/GhcMod/World.hs b/core/GhcMod/World.hs similarity index 86% rename from core/Language/Haskell/GhcMod/World.hs rename to core/GhcMod/World.hs index d166b49..374a1d5 100644 --- a/core/Language/Haskell/GhcMod/World.hs +++ b/core/GhcMod/World.hs @@ -1,10 +1,10 @@ -module Language.Haskell.GhcMod.World where +module GhcMod.World where -import Language.Haskell.GhcMod.GhcPkg -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Monad.Types -import Language.Haskell.GhcMod.Utils +import GhcMod.GhcPkg +import GhcMod.PathsAndFiles +import GhcMod.Types +import GhcMod.Monad.Types +import GhcMod.Utils import Control.Applicative import Data.Maybe diff --git a/elisp/ghc.el b/elisp/ghc.el index 5c35f05..bb054b2 100644 --- a/elisp/ghc.el +++ b/elisp/ghc.el @@ -28,7 +28,7 @@ (< emacs-minor-version minor))) (error "ghc-mod requires at least Emacs %d.%d" major minor))) -(defconst ghc-version "5.6.0.0") +(defconst ghc-version "5.8.0.0") (defgroup ghc-mod '() "ghc-mod customization") diff --git a/ghc-mod.cabal b/ghc-mod.cabal index 3a11e33..edc6a95 100644 --- a/ghc-mod.cabal +++ b/ghc-mod.cabal @@ -1,5 +1,5 @@ Name: ghc-mod -Version: 5.6.0.0 +Version: 5.8.0.0 Author: Kazu Yamamoto , Daniel Gröber , Alejandro Serrano , @@ -30,7 +30,7 @@ Data-Files: elisp/Makefile elisp/*.el Extra-Source-Files: ChangeLog README.md - core/Language/Haskell/GhcMod/Monad/Compat.hs_h + core/GhcMod/Monad/Compat.hs_h test/data/annotations/*.hs test/data/broken-cabal/*.cabal test/data/broken-sandbox/cabal.sandbox.config @@ -110,68 +110,67 @@ Library HS-Source-Dirs: ., core, shared Exposed-Modules: GhcMod - GhcModExe.Boot - GhcModExe.Browse - GhcModExe.CaseSplit - GhcModExe.Check - GhcModExe.Debug - GhcModExe.FillSig - GhcModExe.Find - GhcModExe.Flag - GhcModExe.Info - GhcModExe.Internal - GhcModExe.Lang - GhcModExe.Lint - GhcModExe.Modules - GhcModExe.PkgDoc - GhcModExe.Test - Language.Haskell.GhcMod.CabalHelper - Language.Haskell.GhcMod.Caching - Language.Haskell.GhcMod.Caching.Types - Language.Haskell.GhcMod.Convert - Language.Haskell.GhcMod.Cradle - Language.Haskell.GhcMod.CustomPackageDb - Language.Haskell.GhcMod.DebugLogger - Language.Haskell.GhcMod.Doc - Language.Haskell.GhcMod.DynFlags - Language.Haskell.GhcMod.DynFlagsTH - Language.Haskell.GhcMod.Error - Language.Haskell.GhcMod.FileMapping - Language.Haskell.GhcMod.Gap - Language.Haskell.GhcMod.GhcPkg - Language.Haskell.GhcMod.HomeModuleGraph - Language.Haskell.GhcMod.LightGhc - Language.Haskell.GhcMod.Logger - Language.Haskell.GhcMod.Logging - Language.Haskell.GhcMod.Monad - Language.Haskell.GhcMod.Monad.Env - Language.Haskell.GhcMod.Monad.Log - Language.Haskell.GhcMod.Monad.Newtypes - Language.Haskell.GhcMod.Monad.Orphans - Language.Haskell.GhcMod.Monad.Out - Language.Haskell.GhcMod.Monad.State - Language.Haskell.GhcMod.Monad.Types - Language.Haskell.GhcMod.Options.DocUtils - Language.Haskell.GhcMod.Options.Help - Language.Haskell.GhcMod.Options.Options - Language.Haskell.GhcMod.Output - Language.Haskell.GhcMod.PathsAndFiles - Language.Haskell.GhcMod.Pretty - Language.Haskell.GhcMod.Read - Language.Haskell.GhcMod.SrcUtils - Language.Haskell.GhcMod.Stack - Language.Haskell.GhcMod.Target - Language.Haskell.GhcMod.Types - Language.Haskell.GhcMod.Utils - Language.Haskell.GhcMod.World + GhcMod.Exe.Boot + GhcMod.Exe.Browse + GhcMod.Exe.CaseSplit + GhcMod.Exe.Check + GhcMod.Exe.Debug + GhcMod.Exe.FillSig + GhcMod.Exe.Find + GhcMod.Exe.Flag + GhcMod.Exe.Info + GhcMod.Exe.Internal + GhcMod.Exe.Lang + GhcMod.Exe.Lint + GhcMod.Exe.Modules + GhcMod.Exe.PkgDoc + GhcMod.Exe.Test + GhcMod.CabalHelper + GhcMod.Caching + GhcMod.Caching.Types + GhcMod.Convert + GhcMod.Cradle + GhcMod.CustomPackageDb + GhcMod.DebugLogger + GhcMod.Doc + GhcMod.DynFlags + GhcMod.DynFlagsTH + GhcMod.Error + GhcMod.FileMapping + GhcMod.Gap + GhcMod.GhcPkg + GhcMod.HomeModuleGraph + GhcMod.LightGhc + GhcMod.Logger + GhcMod.Logging + GhcMod.Monad + GhcMod.Monad.Env + GhcMod.Monad.Log + GhcMod.Monad.Newtypes + GhcMod.Monad.Orphans + GhcMod.Monad.Out + GhcMod.Monad.State + GhcMod.Monad.Types + GhcMod.Options.DocUtils + GhcMod.Options.Help + GhcMod.Options.Options + GhcMod.Output + GhcMod.PathsAndFiles + GhcMod.Pretty + GhcMod.Read + GhcMod.SrcUtils + GhcMod.Stack + GhcMod.Target + GhcMod.Types + GhcMod.Utils + GhcMod.World Other-Modules: Paths_ghc_mod Utils Data.Binary.Generic System.Directory.ModTime Build-Depends: -- See Note [GHC Boot libraries] - base - , binary + binary , bytestring , containers , deepseq @@ -184,6 +183,7 @@ Library , time , transformers + , base < 4.10 && >= 4.6.0.1 , djinn-ghc < 0.1 && >= 0.0.2.2 , extra < 1.6 && >= 1.4 , fclabels < 2.1 && >= 2.0 @@ -193,7 +193,7 @@ Library , hlint < 2.1 && >= 2.0.8 , monad-control < 1.1 && >= 1 , monad-journal < 0.8 && >= 0.4 - , optparse-applicative == 0.13.0.* + , optparse-applicative < 0.14 && >= 0.13.0.0 , pipes < 4.4 && >= 4.1 , safe < 0.4 && >= 0.3.9 , semigroups < 0.19 && >= 0.10.0 @@ -213,27 +213,27 @@ Library Executable ghc-mod Default-Language: Haskell2010 - Main-Is: GHCModMain.hs + Main-Is: GhcModMain.hs Other-Modules: Paths_ghc_mod - , GHCMod.Options - , GHCMod.Options.Commands - , GHCMod.Version - , GHCMod.Options.ShellParse + , GhcMod.Exe.Options + , GhcMod.Exe.Options.Commands + , GhcMod.Exe.Version + , GhcMod.Exe.Options.ShellParse GHC-Options: -Wall -fno-warn-deprecations -threaded Default-Extensions: ConstraintKinds, FlexibleContexts HS-Source-Dirs: src, shared X-Internal: True Build-Depends: -- See Note [GHC Boot libraries] - base - , directory + directory , filepath , mtl , process + , base < 4.10 && >= 4.6.0.1 , fclabels < 2.1 && >= 2.0 , monad-control < 1.1 && >= 1 - , optparse-applicative == 0.13.0.* + , optparse-applicative < 0.14 && >= 0.13.0.0 , semigroups < 0.19 && >= 0.10.0 , split < 0.3 && >= 0.2.2 @@ -243,7 +243,7 @@ Executable ghc-mod Executable ghc-modi Default-Language: Haskell2010 - Main-Is: GHCModi.hs + Main-Is: GhcModi.hs Other-Modules: Paths_ghc_mod Utils System.Directory.ModTime @@ -254,8 +254,7 @@ Executable ghc-modi HS-Source-Dirs: ., src, shared Build-Depends: -- See Note [GHC Boot libraries] - base - , binary + binary , deepseq , directory , filepath @@ -263,6 +262,8 @@ Executable ghc-modi , process , time + , base < 4.10 && >= 4.6.0.1 + , ghc-mod @@ -273,7 +274,7 @@ Test-Suite doctest Ghc-Options: -Wall Default-Extensions: ConstraintKinds, FlexibleContexts Main-Is: doctests.hs - Build-Depends: base + Build-Depends: base < 4.10 && >= 4.6.0.1 , doctest < 0.12 && >= 0.9.3 @@ -313,14 +314,14 @@ Test-Suite spec Build-Depends: -- See Note [GHC Boot libraries] - base - , containers + containers , directory , filepath , mtl , process , transformers + , base < 4.10 && >= 4.6.0.1 , fclabels < 2.1 && >= 2.0 , hspec < 2.4 && >= 2.0.0 , monad-journal < 0.8 && >= 0.4 @@ -329,7 +330,7 @@ Test-Suite spec if impl(ghc < 7.8) - Build-Depends: convertible < 1.2 && >= 1.1.0.0 + Build-Depends: convertible < 1.2 && >= 1.1.0.0 if impl(ghc >= 8.0) Build-Depends: ghc-boot @@ -345,8 +346,8 @@ Test-Suite shelltest Hs-Source-Dirs: shelltest Type: exitcode-stdio-1.0 Build-Tools: shelltest - Build-Depends: base - , process < 1.5 + Build-Depends: base < 4.10 && >= 4.6.0.1 + , process < 1.5 -- , shelltestrunner >= 1.3.5 if !flag(shelltest) Buildable: False @@ -362,10 +363,10 @@ Benchmark criterion Main-Is: Bench.hs Build-Depends: -- See Note [GHC Boot libraries] - base - , directory + directory , filepath + , base < 4.10 && >= 4.6.0.1 , criterion < 1.2 && >= 1.1.1.0 , temporary < 1.3 && >= 1.2.0.3 diff --git a/src/GHCMod/Options.hs b/src/GhcMod/Exe/Options.hs similarity index 89% rename from src/GHCMod/Options.hs rename to src/GhcMod/Exe/Options.hs index 8549fbd..936dd97 100644 --- a/src/GHCMod/Options.hs +++ b/src/GhcMod/Exe/Options.hs @@ -16,7 +16,7 @@ {-# LANGUAGE OverloadedStrings #-} {-# OPTIONS_GHC -fno-warn-unused-do-bind #-} -module GHCMod.Options ( +module GhcMod.Exe.Options ( parseArgs, parseArgsInteractive, GhcModCommands(..) @@ -25,12 +25,12 @@ module GHCMod.Options ( import Options.Applicative import Options.Applicative.Types -import GHCMod.Options.Commands -import GHCMod.Options.ShellParse -import GHCMod.Version -import Language.Haskell.GhcMod.Options.DocUtils -import Language.Haskell.GhcMod.Options.Options -import Language.Haskell.GhcMod.Types +import GhcMod.Exe.Options.Commands +import GhcMod.Exe.Options.ShellParse +import GhcMod.Exe.Version +import GhcMod.Options.DocUtils +import GhcMod.Options.Options +import GhcMod.Types parseArgs :: IO (Options, GhcModCommands) parseArgs = diff --git a/src/GHCMod/Options/Commands.hs b/src/GhcMod/Exe/Options/Commands.hs similarity index 98% rename from src/GHCMod/Options/Commands.hs rename to src/GhcMod/Exe/Options/Commands.hs index cc9f64f..cd8ef55 100644 --- a/src/GHCMod/Options/Commands.hs +++ b/src/GhcMod/Exe/Options/Commands.hs @@ -16,16 +16,16 @@ {-# LANGUAGE OverloadedStrings #-} {-# OPTIONS_GHC -fno-warn-unused-do-bind #-} -module GHCMod.Options.Commands where +module GhcMod.Exe.Options.Commands where import Data.Semigroup import Options.Applicative import Options.Applicative.Types import Options.Applicative.Builder.Internal -import Language.Haskell.GhcMod.Types -import Language.Haskell.GhcMod.Read -import Language.Haskell.GhcMod.Options.DocUtils -import Language.Haskell.GhcMod.Options.Help +import GhcMod.Types +import GhcMod.Read +import GhcMod.Options.DocUtils +import GhcMod.Options.Help type Symbol = String type Expr = String diff --git a/src/GHCMod/Options/ShellParse.hs b/src/GhcMod/Exe/Options/ShellParse.hs similarity index 96% rename from src/GHCMod/Options/ShellParse.hs rename to src/GhcMod/Exe/Options/ShellParse.hs index 6a74dc2..e9c73d7 100644 --- a/src/GHCMod/Options/ShellParse.hs +++ b/src/GhcMod/Exe/Options/ShellParse.hs @@ -13,7 +13,7 @@ -- -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module GHCMod.Options.ShellParse (parseCmdLine) where +module GhcMod.Exe.Options.ShellParse (parseCmdLine) where import Data.Char import Data.List diff --git a/src/GHCMod/Version.hs b/src/GhcMod/Exe/Version.hs similarity index 97% rename from src/GHCMod/Version.hs rename to src/GhcMod/Exe/Version.hs index c151c04..b27e8c0 100644 --- a/src/GHCMod/Version.hs +++ b/src/GhcMod/Exe/Version.hs @@ -14,7 +14,7 @@ -- You should have received a copy of the GNU Affero General Public License -- along with this program. If not, see . -module GHCMod.Version where +module GhcMod.Exe.Version where import Paths_ghc_mod import Data.Version (showVersion) diff --git a/src/GHCModMain.hs b/src/GhcModMain.hs similarity index 96% rename from src/GHCModMain.hs rename to src/GhcModMain.hs index 2e74b3d..d4c0116 100644 --- a/src/GHCModMain.hs +++ b/src/GhcModMain.hs @@ -7,7 +7,7 @@ import Control.Monad import Data.Typeable (Typeable) import Data.List import Data.List.Split -import Language.Haskell.GhcMod.Pretty +import GhcMod.Pretty import System.FilePath (()) import System.Directory (setCurrentDirectory, getAppUserDataDirectory, removeDirectoryRecursive) @@ -15,12 +15,12 @@ import System.IO import System.Exit import Prelude -import GHCMod.Options import GhcMod -import GhcModExe.Find -import GhcModExe.Internal hiding (MonadIO,liftIO) -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Types +import GhcMod.Exe.Find +import GhcMod.Exe.Options +import GhcMod.Exe.Internal hiding (MonadIO,liftIO) +import GhcMod.Monad +import GhcMod.Types import Exception diff --git a/src/GHCModi.hs b/src/GhcModi.hs similarity index 100% rename from src/GHCModi.hs rename to src/GhcModi.hs diff --git a/test/CabalHelperSpec.hs b/test/CabalHelperSpec.hs index 1645c81..c14ed38 100644 --- a/test/CabalHelperSpec.hs +++ b/test/CabalHelperSpec.hs @@ -4,9 +4,9 @@ module CabalHelperSpec where import Control.Arrow import Control.Applicative import Distribution.Helper -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.Error +import GhcMod.CabalHelper +import GhcMod.PathsAndFiles +import GhcMod.Error import Test.Hspec import System.Directory import System.FilePath diff --git a/test/CradleSpec.hs b/test/CradleSpec.hs index c62a589..02c6d5b 100644 --- a/test/CradleSpec.hs +++ b/test/CradleSpec.hs @@ -2,8 +2,8 @@ module CradleSpec where import Control.Applicative import Data.List (isSuffixOf) -import Language.Haskell.GhcMod.Cradle -import Language.Haskell.GhcMod.Types +import GhcMod.Cradle +import GhcMod.Types import System.Directory (canonicalizePath) import System.FilePath (pathSeparator) import Test.Hspec diff --git a/test/CustomPackageDbSpec.hs b/test/CustomPackageDbSpec.hs index c19c193..f25d59a 100644 --- a/test/CustomPackageDbSpec.hs +++ b/test/CustomPackageDbSpec.hs @@ -1,8 +1,8 @@ module CustomPackageDbSpec where -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.CustomPackageDb -import Language.Haskell.GhcMod.Error +import GhcMod.CabalHelper +import GhcMod.CustomPackageDb +import GhcMod.Error import System.Process import Test.Hspec import Prelude diff --git a/test/FileMappingSpec.hs b/test/FileMappingSpec.hs index 5b50e6c..aec284d 100644 --- a/test/FileMappingSpec.hs +++ b/test/FileMappingSpec.hs @@ -1,7 +1,7 @@ module FileMappingSpec where -import Language.Haskell.GhcMod.FileMapping -import Language.Haskell.GhcMod.Utils (withMappedFile) +import GhcMod.FileMapping +import GhcMod.Utils (withMappedFile) import Test.Hspec import TestUtils import qualified Data.Map as M diff --git a/test/FindSpec.hs b/test/FindSpec.hs index 2ccf346..b98376a 100644 --- a/test/FindSpec.hs +++ b/test/FindSpec.hs @@ -1,7 +1,7 @@ {-# LANGUAGE OverloadedStrings #-} module FindSpec where -import GhcModExe.Find +import GhcMod.Exe.Find import Test.Hspec import TestUtils diff --git a/test/GhcPkgSpec.hs b/test/GhcPkgSpec.hs index 69d9661..19a1604 100644 --- a/test/GhcPkgSpec.hs +++ b/test/GhcPkgSpec.hs @@ -1,8 +1,8 @@ module GhcPkgSpec where -import Language.Haskell.GhcMod.GhcPkg -import Language.Haskell.GhcMod.CabalHelper -import Language.Haskell.GhcMod.CustomPackageDb +import GhcMod.GhcPkg +import GhcMod.CabalHelper +import GhcMod.CustomPackageDb import Test.Hspec import System.Process (system) diff --git a/test/HomeModuleGraphSpec.hs b/test/HomeModuleGraphSpec.hs index 9e10987..8f534e1 100644 --- a/test/HomeModuleGraphSpec.hs +++ b/test/HomeModuleGraphSpec.hs @@ -18,8 +18,8 @@ module HomeModuleGraphSpec where -import Language.Haskell.GhcMod.HomeModuleGraph -import Language.Haskell.GhcMod.LightGhc +import GhcMod.HomeModuleGraph +import GhcMod.LightGhc import TestUtils import GHC diff --git a/test/PathsAndFilesSpec.hs b/test/PathsAndFilesSpec.hs index d3611f1..cd0f6d5 100644 --- a/test/PathsAndFilesSpec.hs +++ b/test/PathsAndFilesSpec.hs @@ -1,9 +1,9 @@ module PathsAndFilesSpec where -import Language.Haskell.GhcMod.PathsAndFiles -import Language.Haskell.GhcMod.Cradle -import qualified Language.Haskell.GhcMod.Utils as U +import GhcMod.PathsAndFiles +import GhcMod.Cradle +import qualified GhcMod.Utils as U import Control.Monad.Trans.Maybe import System.Directory diff --git a/test/ShellParseSpec.hs b/test/ShellParseSpec.hs index 2c5cefe..751f404 100644 --- a/test/ShellParseSpec.hs +++ b/test/ShellParseSpec.hs @@ -1,7 +1,7 @@ module ShellParseSpec where -import GHCMod.Options.ShellParse +import GhcMod.Exe.Options.ShellParse import Test.Hspec diff --git a/test/TargetSpec.hs b/test/TargetSpec.hs index f5ceef2..dcc2362 100644 --- a/test/TargetSpec.hs +++ b/test/TargetSpec.hs @@ -1,9 +1,9 @@ {-# LANGUAGE OverloadedStrings #-} module TargetSpec where -import Language.Haskell.GhcMod.Target -import Language.Haskell.GhcMod.LightGhc -import Language.Haskell.GhcMod.Gap +import GhcMod.Target +import GhcMod.LightGhc +import GhcMod.Gap import Test.Hspec import TestUtils diff --git a/test/TestUtils.hs b/test/TestUtils.hs index af5367b..3d252f1 100644 --- a/test/TestUtils.hs +++ b/test/TestUtils.hs @@ -10,14 +10,14 @@ module TestUtils ( , shouldReturnError , isPkgDbAt , isPkgConfDAt - , module Language.Haskell.GhcMod.Monad - , module Language.Haskell.GhcMod.Types + , module GhcMod.Monad + , module GhcMod.Types ) where -import Language.Haskell.GhcMod.Logging -import Language.Haskell.GhcMod.Monad -import Language.Haskell.GhcMod.Cradle -import Language.Haskell.GhcMod.Types +import GhcMod.Logging +import GhcMod.Monad +import GhcMod.Cradle +import GhcMod.Types import Control.Arrow import Control.Category