D$      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                             !"#None$%&'(NonevNone6V^ )Possible package database configurations.<Use the global cabal package database (like when using ghc).)Use the sandboxed cabal package database. 5Use the stack package databases (local and snapshot). %Set the package database explicitely. Decide which type of project we are dealing with based on the package folders. Should only be invoked if the user did not select the project-type. FFinds the location of the package database based on the configuration.^Gets the (probable) location of autogen folder depending on which type of build we are using.)URun a command and return its result if successful display an error message otherwise.     None.Command line options shared by CLI and daemon.,Command line options for the daemon process. !" !" None68=80The possible responses that the server can give.9A response to KeepAlive: Tells the version of the server.;qAn error message marking internal problems or user mistakes. TODO: separate internal problems and user mistakes.<@A response that tells there are errors in the source code given.=BInformation about changes that would be caused by the refactoring.>SThe traversal of the project is done, now the engine is loading the given modules.?'The engine has loaded the given module.@2Returns the flags that are not used by the engine.A%The engine has closed the connection.K&The messages expected from the client.L:A simple ping message to check that the server is running.M\A message that instructs the server to reset its internal state and re-load loaded packages.N6Tells the client version and asks the servers version.O0Sets the package database for the engine to use.PRegisters packages to the engine. They will be subject to subsequent refactorings. Will cause the packages to be loaded, resulting in LoadingModules, LoadedModule or CompilationProblem responses.QcDeregisters the given packages from the engine. They will not be subjects of further refactorings.R}Sets the working directory for the compilation. Important when compiling code that loads resources based on relative pathes.SXSets the compilation flags. The unused flags are returned via the UnusedFlags response.TOrders the engine to perform the refactoring on the module given with the selection and details. Successful refactorings will cause re-loading of modules. If c or dl is not set, after the refactoring, modules are re-loaded, LoadingModules, LoadedModule responses are sent.U-Asks the daemon to undo the last refactoring.V/Stops the engine. It replies with Disconnected.WfInstructs the engine to re-load a changed module. LoadingModules, LoadedModule responses may be sent.XStops the server. OBSOLATEbPAdditional details for the refactoring like the names of generated definitions.c1Stop the daemon after performing the refactoring.d@Don't change the files, send back the result as a unified diff.C%&)('.-,+*/120347658A@?>=<:9;JIHGFEDBCKWVUTSRQPONLXMgfedca_]\[ZY^b`JKLMNOPQRSTUVWXYZ[\]^_`abcdefgi89:;<=>?@ABCDEFGHIJ34567l/012mkjh&'()*+,-.n%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgNoneDl{1An abstraction over the connection to the client.KConnect to the client running in a separate process using socket connectionAConnect to the client running in the same process using a channel{|~}{|}~{|}~None"#<Jq3This data structure identifies a module collection.An alias for module namesThe state of a module.jThe modules of a library, executable, test or benchmark. A package contains one or more module collection.HSets up the ghc environment for compiling the modules of this collection3Sets up the ghc environment for dependency analysis28 None$<NQV]hv}Extract module-related information from different kind of package components (library, executable, test-suite or benchmark).5Creates a key for registering this package component.3Gets the build info field from a package component.@Get the names of all the modules used by this package component.tGets if some of the modules are defined is source files that are not in the expected location or named as expected.Checks if a module is exposed by the package component, so it is necessary to compile. Some of the components may have modules that are only conditionally imported by other modules.LGets the Main module in the case of executables, benchmarks and test suites.!Gets all ModuleCollections from a list of source directories. It also orders the source directories that are package roots so that they can be loaded in the order they are defined (no backward imports). This matters in those cases because for them there can be special compilation flags.Sorts model collection in an order to remove all backward references. Works because module collections defined by directories cannot be recursive. 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. Only returns the non-boot haskell modules, the boot modules will be found during loading.VLoad the module giving a directory. All modules loaded from the folder and subfolders.Load the module using a cabal file. The modules described in the cabal file will be loaded. The flags and extensions set in the cabal file will be used by default.kA default method of getting the main module using the ghc-options field, checking for the option -main-is.JChecks if the module collection created from a folder without .cabal file.PModify the dynamic flags to match the dependencies requested in the .cabal file._Only use the dependencies that are explicitely enabled. (As cabal does opposed to as ghc does.)STransform dependencies of a module collection into the package flags of the GHC APISets the configuration for loading all the modules from the whole project. Combines the configuration of all package fragments. This solution is not perfect (it would be better to load all package fragments separately), but it is how it works. See .Collects the compilation options and enabled extensions from Cabal's build info representation. This setup will be used when loading all packages in the project. See .yCollects the compilation options and enabled extensions from Cabal's build info representation for a single module. See compileInContext. NoneV]|W!Handlers for generic exceptions: *, +, ,.lHint text and continuation suggestion for different kinds of errors based on pattern matching on error text.uHint text and continuation suggestion for different kinds of source problems based on pattern matching on error text. None"#$ xThe actual state of the daemon process. Contains loaded modules and user settings. The GHC state is handled separately./The package components loaded into the session.KThe package database that is selected and a flag to decide if it is forced.CGHC flags for compiling modules. Overrides settings in cabal files.3The pathes where the package databases are located.4True if in the process of shutting down the session.4True if in the process of shutting down the session.0Information about the file system watch process.KExtra threads started for handling the information from the watch process.xMarks files as being modified by this process Changes detected on marked files will not invalidate refactoring history.%An initial state of a daemon session. None<QVh 0Get the name of a module collection from its Id.UFind the module collection where the given module is contained. Based on module name.ZFind the module collection where the given module is contained. Based on source file name.jFind the module collection where the given module is contained. Based on source file name and module name.:Find the module with the given name. Based on module name.?Find the module with the given name. Based on source file name.7Get the module with the given name and source file key.:Remove a module with the given name. Based on module name.aRemove a module with the given name from a module collection. Based on module name and file path.Check if the given module needs code generation. Finds the module if no source file name is present and module names check or if both module names and source file names check.Marks the given module for code generation. Finds the module if no source file name is present and module names check or if both module names and source file names check. Idempotent operation.cCheck if the given module has been already loaded. Based on both module name and source file name.QInsert a module with a source file key to our database if it wasn't there already   None<N^h` yLoad packages from the given directories. Loads modules, performs the given callback action, warns for duplicate modules.>Loads the packages that are declared visible (by .cabal file).JGet the module that is selected for refactoring and all the other modules. TReload the modules that have been changed (given by predicate). Pefrom the callback. Clears the given modules from the GHC state to enable re-loading them From the Haskell-tools state we only clear them individually, when their module collection is determined. Get all modules that can be accessed from a given set of modules. Can be used to select which modules need to be reloaded after a change. *Reload a given module. Perform a callback. 8Select which module collection we think the module is in5Prepares the DynFlags for the compilation of a module4Prepares the DynFlags for travesing the module graphFinds out if a newly added module forces us to generate code for another one. If the other is already loaded it will be reloaded.Re-load the module with code generation enabled. Must be used when the module had already been loaded, but code generation were not enabled by then.Check which modules can be reached from the module, if it uses template haskell. A definition that needs code generation can be inside a module that does not uses the TemplateHaskell extension.           SafeNone "#<FNT]^he -)Context for responding to a user request.fThis function does the real job of acting upon client messages in a stateful environment of a client.bUpdates the state of the tool after some files have been changed (possibly by another application).<Reloads changed modules to have an up-to-date version loaded//Creates a compressed set of changes in one file0cCreates a unified-style diff of two texts. Only used when the user wants to know what would change.1GUndo a refactoring change using the information that was saved earlier.2OUndo the changes in one file using the information that was saved earlier. See /.3%Get the files added by a refactoring.4'Get the files changed by a refactoring.5'Get the files removed by a refactoring.-6789:None"#V^Starts the watch process and a thread that receives notifications from it. The notification thread will invoke updates on the daemon state to re-load files.;Stops the watch process and all threads associated with it.None "#<FTV^h Starts the daemon process. This will not return until the daemon stops. You can use this entry point when the other endpoint of the client connection is not needed, for example, when you use socket connection to connect to the daemon process.!Starts the daemon process. This will not return until the daemon stops. The daemon process is parameterized by the refactorings you can use in it. This entry point gives back the other endpoint of the connection so it can be used to run the daemon in the same process."lStarts the server loop, receiving requests from the client and updated the server state according to these.#OResponds to a client request by modifying the daemon and GHC state accordingly. !"# !"#; !"#$$%&'()*++,-./0123456789:;<=>?@ABBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk)lmnopqrstuvwxyz{|}~                                    ! " #$%&'()*+,-./-.0-.1-.2-.3456756859:;<=>?@ABC;DEFGH3haskell-tools-daemon-1.0.0.4-5xRPvdYipy5J23vtgQpZOi+Language.Haskell.Tools.Daemon.MapExtensions)Language.Haskell.Tools.Daemon.ModuleGraph'Language.Haskell.Tools.Daemon.PackageDB%Language.Haskell.Tools.Daemon.Options&Language.Haskell.Tools.Daemon.Protocol"Language.Haskell.Tools.Daemon.Mode,Language.Haskell.Tools.Daemon.Representation(Language.Haskell.Tools.Daemon.GetModules+Language.Haskell.Tools.Daemon.ErrorHandling#Language.Haskell.Tools.Daemon.State#Language.Haskell.Tools.Daemon.Utils%Language.Haskell.Tools.Daemon.SessionPaths_haskell_tools_daemon$Language.Haskell.Tools.Daemon.Update#Language.Haskell.Tools.Daemon.WatchLanguage.Haskell.Tools.DaemonsetExtensionFlag'unSetExtensionFlag'getModFromNodemoduleGraphNodessupportingModulesdependentModules PackageDB DefaultDBCabalSandboxDBStackDB ExplicitDB packageDBPath decidePkgDB packageDBLoc detectAutogen$fFromJSONPackageDB $fEqPackageDB$fShowPackageDB$fGenericPackageDBSharedDaemonOptionsnoWatchwatchExe generateCodedisableHistoryghcFlags projectType DaemonOptions daemonVersion portNumber silentMode sharedOptionsparseDaemonCLIsharedOptionsParser$fShowSharedDaemonOptions$fShowDaemonOptionsFileDiff UndoRefactor RemoveAddedRestoreRemoved UndoChangesundoRemovePathundoRestorePathundoRestoreContentsundoChangedPathundoDiffSeverityErrorWarningInfoMarkerlocationseveritymessage ResponseMsgKeepAliveResponseHandshakeResponse ErrorMessageCompilationProblemDiffInfoLoadingModules LoadedModule UnusedFlags Disconnected serverVersionerrorMsgmarkers errorHintsdiffInfo modulesToLoadloadedModulePathloadedModuleName unusedFlags ClientMessage KeepAliveReset Handshake SetPackageDB AddPackagesRemovePackages SetWorkingDir SetGHCFlagsPerformRefactoringUndoLast DisconnectReLoadStop clientVersionpkgDB addedPathes removedPathes newWorkingDir refactoring modulePatheditorSelectiondetails shutdownAfterdiffMode addedModuleschangedModulesremovedModules$fToJSONSrcSpan$fFromJSONClientMessage$fToJSONSeverity$fToJSONMarker $fShowMarker$fToJSONResponseMsg$fToJSONUndoRefactor$fShowClientMessage$fGenericClientMessage$fShowSeverity$fGenericSeverity $fEqSeverity$fGenericMarker $fEqMarker$fShowResponseMsg$fGenericResponseMsg$fShowUndoRefactor$fGenericUndoRefactor$fNFDataUndoRefactor WorkingMode daemonConnectdaemonDisconnect daemonSend daemonReceive socketMode channelModeModuleCollectionId DirectoryMC LibraryMC ExecutableMC TestSuiteMC BenchmarkMC ModuleNameStr CodeGenPolicy NoCodeGenInterpretedCode GeneratedCode ModuleRecordModuleNotLoaded ModuleParsed ModuleRenamedModuleTypeChecked_modRecCodeGen_recModuleExposed_parsedRecModule _modRecMS_renamedRecModule_typedRecModuleModuleCollection_mcId _mcLoadDone_mcRoot _mcSourceDirs_mcModuleFiles _mcModules _mcFlagSetup_mcLoadFlagSetup_mcDependencies modCollToSfkisLoaded$fShowModuleCollection$fEqModuleCollection$fEqCodeGenPolicy$fOrdCodeGenPolicy$fShowCodeGenPolicy$fEqModuleCollectionId$fOrdModuleCollectionId$fShowModuleCollectionIdmcDependencies mcFlagSetupmcId mcLoadDonemcLoadFlagSetup mcModuleFiles mcModulesmcRoot mcSourceDirs modRecCodeGenmodRecMSparsedRecModulerecModuleExposedrenamedRecModuletypedRecModule$fShowModuleRecordToModuleCollectionmkModuleCollKey getBuildInfogetModuleNamesgetModuleSourceFilesneedsToCompilegetMainUnsupportedPackage getAllModulesorderMCs getModulesmodulesFromDirectorysrcDirFromRootmodulesFromCabalFilegetMain' isDirectoryMCapplyDependenciesonlyUseEnableddependencyToPkgFlagsetupLoadFlagsloadFlagsFromBuildInfoflagsFromBuildInfo$fExceptionUnsupportedPackage$fToModuleCollectionBenchmark$fToModuleCollectionTestSuite$fToModuleCollectionExecutable$fToModuleCollectionLibrary$fShowUnsupportedPackageuserExceptionHandlersexceptionHandlers getProblemshandleGHCExceptionhandleSourceProblemDaemonSessionState _refSessMCs _packageDB _ghcFlagsSet _pkgDbFlags_packageDBLocs_exiting _undoStack _watchProc _watchThreads _touchedFiles initSession resetSessionexiting ghcFlagsSet packageDB packageDBLocs pkgDbFlags refSessMCs touchedFiles undoStack watchProc watchThreadsmoduleCollectionPkgIdlookupModuleColllookupSourceFileColllookupModuleCollectionlookupModuleInSCslookupModInSCslookupSFKInSCs removeModuleremoveModuleMSneedsGeneratedCodecodeGeneratedForisAlreadyLoadedinsertIfMissing DaemonSessionloadPackagesFromloadVisiblePackages getFileModsreloadChangedModules clearModulesgetReachableModules reloadModuledecideMCwithFlagsForModulewithLoadFlagsForModulescheckEvaluatedModscodeGenForModulegetEvaluatedModsversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName updateClientupdateForFileChangesinitGhcSessioncreateWatchProcess' stopWatch runDaemon' runDaemon serverLoop respondTo5haskell-tools-refactor-1.0.0.4-KMysqG6c1zVATwhJvQEWAZ0Language.Haskell.Tools.Refactor.Utils.ExtensionstranslateExtension impliedXFlagsturnOffturnOnexpandExtensionrunCommandExpectOKbaseGHC.IO.Exception IOExceptionAsyncException GHC.Exception SomeException UpdateCtx reloadModules createUndocreateUnifiedDiff performUndoperformUndoChanges getUndoAddedgetUndoChangedgetUndoRemovedoptions refactoringsresponsewarnMVar