-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Refactoring Tool for Haskell
--   
--   Contains a set of refactorings based on the Haskell-Tools framework to
--   easily transform a Haskell program. For the descriptions of the
--   implemented refactorings, see the homepage.
@package haskell-tools-refactor
@version 0.3.0.1

module Language.Haskell.Tools.Refactor.RefactorBase
type UnnamedModule dom = Ann UModule dom SrcTemplateStage

-- | The name of the module and the AST
type ModuleDom dom = (String, UnnamedModule dom)

-- | A refactoring that only affects one module
type LocalRefactoring dom = UnnamedModule dom -> LocalRefactor dom (UnnamedModule dom)

-- | The type of a refactoring
type Refactoring dom = ModuleDom dom -> [ModuleDom dom] -> Refactor [RefactorChange dom]

-- | Change in the project, modification or removal of a module.
data RefactorChange dom
ContentChanged :: (ModuleDom dom) -> RefactorChange dom
[fromContentChanged] :: RefactorChange dom -> (ModuleDom dom)
ModuleRemoved :: String -> RefactorChange dom
[removedModuleName] :: RefactorChange dom -> String

-- | Performs the given refactoring, transforming it into a Ghc action
runRefactor :: (HasModuleInfo dom) => ModuleDom dom -> [ModuleDom dom] -> Refactoring dom -> Ghc (Either String [RefactorChange dom])

-- | Wraps a refactoring that only affects one module. Performs the
--   per-module finishing touches.
localRefactoring :: HasModuleInfo dom => LocalRefactoring dom -> Refactoring dom

-- | Transform the result of the local refactoring
localRefactoringRes :: HasModuleInfo dom => ((UnnamedModule dom -> UnnamedModule dom) -> a -> a) -> UnnamedModule dom -> LocalRefactor dom a -> Refactor a

-- | Adds the imports that bring names into scope that are needed by the
--   refactoring
addGeneratedImports :: [Name] -> Ann UModule dom SrcTemplateStage -> Ann UModule dom SrcTemplateStage

-- | Input and output information for the refactoring
newtype LocalRefactorT dom m a
LocalRefactorT :: WriterT [Name] (ReaderT (RefactorCtx dom) m) a -> LocalRefactorT dom m a
[fromRefactorT] :: LocalRefactorT dom m a -> WriterT [Name] (ReaderT (RefactorCtx dom) m) a

-- | The information a refactoring can use
data RefactorCtx dom
RefactorCtx :: Module -> Ann UModule dom SrcTemplateStage -> [Ann UImportDecl dom SrcTemplateStage] -> RefactorCtx dom
[refModuleName] :: RefactorCtx dom -> Module
[refCtxRoot] :: RefactorCtx dom -> Ann UModule dom SrcTemplateStage
[refCtxImports] :: RefactorCtx dom -> [Ann UImportDecl dom SrcTemplateStage]

-- | A monad that can be used to refactor
class Monad m => RefactorMonad m
refactError :: RefactorMonad m => String -> m a
liftGhc :: RefactorMonad m => Ghc a -> m a

-- | The refactoring monad for a given module
type LocalRefactor dom = LocalRefactorT dom Refactor

-- | The refactoring monad for the whole project
type Refactor = ExceptT String Ghc
registeredNamesFromPrelude :: [Name]
otherNamesFromPrelude :: [String]
qualifiedName :: Name -> String
referenceName :: (HasImportInfo dom, HasModuleInfo dom) => Name -> LocalRefactor dom (Ann UName dom SrcTemplateStage)
referenceOperator :: (HasImportInfo dom, HasModuleInfo dom) => Name -> LocalRefactor dom (Ann UOperator dom SrcTemplateStage)

-- | Create a name that references the definition. Generates an import if
--   the definition is not yet imported.
referenceName' :: (HasImportInfo dom, HasModuleInfo dom) => ([String] -> Name -> Ann nt dom SrcTemplateStage) -> Name -> LocalRefactor dom (Ann nt dom SrcTemplateStage)

-- | Reference the name by the shortest suitable import
referenceBy :: ([String] -> Name -> Ann nt dom SrcTemplateStage) -> Name -> [Ann UImportDecl dom SrcTemplateStage] -> Ann nt dom SrcTemplateStage

-- | Different classes of definitions that have different kind of names.
data NameClass

-- | Normal value definitions: functions, variables
Variable :: NameClass

-- | Data constructors
Ctor :: NameClass

-- | Functions with operator-like names
ValueOperator :: NameClass

-- | Constructors with operator-like names
DataCtorOperator :: NameClass

-- | UType definitions with operator-like names
SynonymOperator :: NameClass

-- | Get which category does a given name belong to
classifyName :: RefactorMonad m => Name -> m NameClass

-- | Checks if a given name is a valid module name
validModuleName :: String -> Bool

-- | Check if a given name is valid for a given kind of definition
nameValid :: NameClass -> String -> Bool
isIdStartChar :: Char -> Bool
isOperatorChar :: Char -> Bool
instance GhcMonad.GhcMonad m => GhcMonad.GhcMonad (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance (DynFlags.HasDynFlags m, GHC.Base.Monad m) => DynFlags.HasDynFlags (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance GHC.Base.Monad m => Control.Monad.Writer.Class.MonadWriter [Name.Name] (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance GHC.Base.Monad m => Control.Monad.Reader.Class.MonadReader (Language.Haskell.Tools.Refactor.RefactorBase.RefactorCtx dom) (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance GHC.Base.Monad m => GHC.Base.Monad (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance GHC.Base.Functor m => GHC.Base.Functor (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom m)
instance (GhcMonad.GhcMonad m, GHC.Base.Monoid s) => GhcMonad.GhcMonad (Control.Monad.Trans.Writer.Lazy.WriterT s m)
instance (Exception.ExceptionMonad m, GHC.Base.Monoid s) => Exception.ExceptionMonad (Control.Monad.Trans.Writer.Lazy.WriterT s m)
instance GhcMonad.GhcMonad m => GhcMonad.GhcMonad (Control.Monad.Trans.Reader.ReaderT s m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (Control.Monad.Trans.Reader.ReaderT s m)
instance GhcMonad.GhcMonad m => GhcMonad.GhcMonad (Control.Monad.Trans.Except.ExceptT s m)
instance Exception.ExceptionMonad m => Exception.ExceptionMonad (Control.Monad.Trans.Except.ExceptT s m)
instance Control.Monad.Trans.Class.MonadTrans (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactorT dom)
instance Language.Haskell.Tools.Refactor.RefactorBase.RefactorMonad Language.Haskell.Tools.Refactor.RefactorBase.Refactor
instance Language.Haskell.Tools.Refactor.RefactorBase.RefactorMonad (Language.Haskell.Tools.Refactor.RefactorBase.LocalRefactor dom)
instance Language.Haskell.Tools.Refactor.RefactorBase.RefactorMonad m => Language.Haskell.Tools.Refactor.RefactorBase.RefactorMonad (Control.Monad.Trans.State.Lazy.StateT s m)


-- | Defines utility methods that prepare Haskell modules for refactoring
module Language.Haskell.Tools.Refactor.Prepare
tryRefactor :: Refactoring IdDom -> String -> IO ()

-- | Set the given flags for the GHC session
useFlags :: [String] -> Ghc [String]

-- | Initialize GHC flags to default values that support refactoring
initGhcFlags :: Ghc ()

-- | Use the given source directories
useDirs :: [FilePath] -> Ghc ()

-- | Translates module name and working directory into the name of the file
--   where the given module should be defined
toFileName :: String -> String -> FilePath

-- | Translates module name and working directory into the name of the file
--   where the boot module should be defined
toBootFileName :: String -> String -> FilePath

-- | Load the summary of a module given by the working directory and module
--   name.
loadModule :: String -> String -> Ghc ModSummary

-- | The final version of our AST, with type infromation added
type TypedModule = Ann UModule IdDom SrcTemplateStage

-- | Get the typed representation from a type-correct program.
parseTyped :: ModSummary -> Ghc TypedModule
data IsBoot
NormalHs :: IsBoot
IsHsBoot :: IsBoot
readSrcSpan :: String -> String -> RealSrcSpan
readSrcLoc :: String -> String -> RealSrcLoc
instance GHC.Show.Show Language.Haskell.Tools.Refactor.Prepare.IsBoot
instance GHC.Classes.Ord Language.Haskell.Tools.Refactor.Prepare.IsBoot
instance GHC.Classes.Eq Language.Haskell.Tools.Refactor.Prepare.IsBoot

module Language.Haskell.Tools.Refactor.ListOperations
filterList :: (Ann e dom SrcTemplateStage -> Bool) -> AnnListG e dom SrcTemplateStage -> AnnListG e dom SrcTemplateStage

-- | Replaces the list with a new one with the given elements, keeping the
--   most common separator as the new one.
replaceList :: [Ann e dom SrcTemplateStage] -> AnnListG e dom SrcTemplateStage -> AnnListG e dom SrcTemplateStage

-- | Inserts the element in the places where the two positioning functions
--   (one checks the element before, one the element after) allows the
--   placement.
insertWhere :: Ann e dom SrcTemplateStage -> (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> AnnListG e dom SrcTemplateStage -> AnnListG e dom SrcTemplateStage

-- | Checks where the element will be inserted given the two positioning
--   functions.
insertIndex :: (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> (Maybe (Ann e dom SrcTemplateStage) -> Bool) -> [Ann e dom SrcTemplateStage] -> Maybe Int
replaceWithJust :: Ann e dom SrcTemplateStage -> AnnMaybe e dom -> AnnMaybe e dom

module Language.Haskell.Tools.Refactor.GetModules

-- | Get modules of the project with the indicated root directory. If there
--   is a cabal file, it uses that, otherwise it just scans the directory
--   recursively for haskell sourcefiles.
getModules :: FilePath -> IO [([FilePath], [String])]
modulesFromCabalFile :: FilePath -> IO [([FilePath], [String])]
modulesFromDirectory :: FilePath -> FilePath -> IO [String]
srcDirFromRoot :: FilePath -> String -> FilePath


-- | Utilities for transformations that work on both top-level and local
--   definitions
module Language.Haskell.Tools.Refactor.BindingElem

-- | A type class for handling definitions that can appear as both
--   top-level and local definitions
class NamedElement d => BindingElem d

-- | Accesses a type signature definition in a local or top-level
--   definition
sigBind :: BindingElem d => Simple Partial (Ann d dom SrcTemplateStage) (TypeSignature dom)

-- | Accesses a value or function definition in a local or top-level
--   definition
valBind :: BindingElem d => Simple Partial (Ann d dom SrcTemplateStage) (ValueBind dom)

-- | Creates a new definition from a type signature
createTypeSig :: BindingElem d => TypeSignature dom -> Ann d dom SrcTemplateStage

-- | Creates a new definition from a value or function definition
createBinding :: BindingElem d => ValueBind dom -> Ann d dom SrcTemplateStage

-- | Checks if a given definition is a type signature
isTypeSig :: BindingElem d => Ann d dom SrcTemplateStage -> Bool

-- | Checks if a given definition is a function or value binding
isBinding :: BindingElem d => Ann d dom SrcTemplateStage -> Bool
getValBindInList :: (BindingElem d) => RealSrcSpan -> AnnListG d dom SrcTemplateStage -> Maybe (ValueBind dom)
valBindsInList :: BindingElem d => Simple Traversal (AnnListG d dom SrcTemplateStage) (ValueBind dom)
instance Language.Haskell.Tools.Refactor.BindingElem.BindingElem Language.Haskell.Tools.AST.Representation.Decls.UDecl
instance Language.Haskell.Tools.Refactor.BindingElem.BindingElem Language.Haskell.Tools.AST.Representation.Binds.ULocalBind


-- | Defines the API for refactorings
module Language.Haskell.Tools.Refactor

-- | Extracts or modifies the concrete range corresponding to a given
--   source info. In case of lists and optional elements, it may not
--   contain the elements inside.
class HasRange a
getRange :: HasRange a => a -> SrcSpan
setRange :: HasRange a => SrcSpan -> a -> a
annListElems :: RefMonads w r => Reference w r (MU *) (MU *) (AnnListG elem0 dom0 stage0) (AnnListG elem0 dom0 stage0) [Ann elem0 dom0 stage0] [Ann elem0 dom0 stage0]
annList :: (RefMonads w r, MonadPlus r, Morph Maybe r, Morph [] r) => Reference w r (MU *) (MU *) (AnnListG e d s) (AnnListG e d s) (Ann e d s) (Ann e d s)
annJust :: (Functor w, Applicative w, Monad w, Functor r, Applicative r, MonadPlus r, Morph Maybe r) => Reference w r (MU *) (MU *) (AnnMaybeG e d s) (AnnMaybeG e d s) (Ann e d s) (Ann e d s)
annMaybe :: RefMonads w r => Reference w r (MU *) (MU *) (AnnMaybeG elem0 dom0 stage0) (AnnMaybeG elem0 dom0 stage0) (Maybe (Ann elem0 dom0 stage0)) (Maybe (Ann elem0 dom0 stage0))
isAnnNothing :: AnnMaybeG e d s -> Bool

-- | Class for domain configuration markers
class (Typeable * d, Data d, (~) * (SemanticInfo' d SameInfoDefaultCls) NoSemanticInfo, Data (SemanticInfo' d SameInfoNameCls), Data (SemanticInfo' d SameInfoExprCls), Data (SemanticInfo' d SameInfoImportCls), Data (SemanticInfo' d SameInfoModuleCls), Data (SemanticInfo' d SameInfoWildcardCls), Show (SemanticInfo' d SameInfoNameCls), Show (SemanticInfo' d SameInfoExprCls), Show (SemanticInfo' d SameInfoImportCls), Show (SemanticInfo' d SameInfoModuleCls), Show (SemanticInfo' d SameInfoWildcardCls)) => Domain d

-- | A short form of showing a range, without file name, for debugging
--   purposes.
shortShowSpan :: SrcSpan -> String

module Language.Haskell.Tools.Refactor.Predefined.DataToNewtype
dataToNewtype :: Domain dom => LocalRefactoring dom

module Language.Haskell.Tools.Refactor.Predefined.DollarApp
dollarApp :: DollarDomain dom => RealSrcSpan -> LocalRefactoring dom
type DollarDomain dom = (HasImportInfo dom, HasModuleInfo dom, HasFixityInfo dom, HasNameInfo dom)

module Language.Haskell.Tools.Refactor.Predefined.ExtractBinding
extractBinding' :: ExtractBindingDomain dom => RealSrcSpan -> String -> LocalRefactoring dom
type ExtractBindingDomain dom = (HasNameInfo dom, HasDefiningInfo dom, HasScopeInfo dom)

module Language.Haskell.Tools.Refactor.Predefined.GenerateExports

-- | Creates an export list that imports standalone top-level definitions
--   with all of their contained definitions
generateExports :: DomGenerateExports dom => LocalRefactoring dom
type DomGenerateExports dom = (Domain dom, HasNameInfo dom)

module Language.Haskell.Tools.Refactor.Predefined.GenerateTypeSignature

-- | Perform the refactoring on either local or top-level definition
generateTypeSignature :: GenerateSignatureDomain dom => Simple Traversal (Module dom) (DeclList dom) -> Simple Traversal (Module dom) (LocalBindList dom) -> (forall d. (BindingElem d) => AnnList d dom -> Maybe (ValueBind dom)) -> LocalRefactoring dom
generateTypeSignature' :: GenerateSignatureDomain dom => RealSrcSpan -> LocalRefactoring dom
type GenerateSignatureDomain dom = (HasModuleInfo dom, HasIdInfo dom, HasImportInfo dom)

module Language.Haskell.Tools.Refactor.Predefined.IfToGuards
ifToGuards :: Domain dom => RealSrcSpan -> LocalRefactoring dom

module Language.Haskell.Tools.Refactor.Predefined.OrganizeImports
organizeImports :: forall dom. OrganizeImportsDomain dom => LocalRefactoring dom
type OrganizeImportsDomain dom = (HasNameInfo dom, HasImportInfo dom)

module Language.Haskell.Tools.Refactor.Predefined.RenameDefinition
renameDefinition :: DomainRenameDefinition dom => Name -> [Name] -> String -> Refactoring dom
renameDefinition' :: forall dom. DomainRenameDefinition dom => RealSrcSpan -> String -> Refactoring dom
type DomainRenameDefinition dom = (HasNameInfo dom, HasScopeInfo dom, HasDefiningInfo dom, HasImplicitFieldsInfo dom, HasModuleInfo dom)


-- | Defines common utilities for using refactorings. Provides an interface
--   for both demo, command line and integrated tools.
module Language.Haskell.Tools.Refactor.Perform

-- | Executes a given command on the selected module and given other
--   modules
performCommand :: (HasModuleInfo dom, DomGenerateExports dom, OrganizeImportsDomain dom, DomainRenameDefinition dom, ExtractBindingDomain dom, GenerateSignatureDomain dom) => RefactorCommand -> ModuleDom dom -> [ModuleDom dom] -> Ghc (Either String [RefactorChange dom])

-- | A refactoring command
data RefactorCommand
NoRefactor :: RefactorCommand
OrganizeImports :: RefactorCommand
GenerateExports :: RefactorCommand
GenerateSignature :: RealSrcSpan -> RefactorCommand
RenameDefinition :: RealSrcSpan -> String -> RefactorCommand
ExtractBinding :: RealSrcSpan -> String -> RefactorCommand
readCommand :: String -> String -> RefactorCommand
analyzeCommand :: String -> String -> [String] -> RefactorCommand
instance GHC.Show.Show Language.Haskell.Tools.Refactor.Perform.RefactorCommand