!%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                              !"#$None'z%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Nonehaskell-tools-daemon indicating if a module is a boot module or not. We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.haskell-tools-daemon Tests if an 9 is a boot file, primarily for constructing elements of  BuildModule.   None6V^$3 haskell-tools-daemon)Possible package database configurations.haskell-tools-daemon<Use the global cabal package database (like when using ghc).haskell-tools-daemon)Use the sandboxed cabal package database.haskell-tools-daemon5Use the stack package databases (local and snapshot).haskell-tools-daemon%Set the package database explicitely.haskell-tools-daemonDecide 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.haskell-tools-daemonFFinds the location of the package database based on the configuration.haskell-tools-daemon^Gets the (probable) location of autogen folder depending on which type of build we are using.haskell-tools-daemonURun a command and return its result if successful display an error message otherwise.  None& haskell-tools-daemon.Command line options shared by CLI and daemon.(haskell-tools-daemon,Command line options for the daemon process. !"#$%&'()-*+,./()-*+,. !"#$%&'/None68S<haskell-tools-daemon0The possible responses that the server can give.=haskell-tools-daemonA response to KeepAlive>haskell-tools-daemon Tells the version of the server.?haskell-tools-daemonqAn error message marking internal problems or user mistakes. TODO: separate internal problems and user mistakes.@haskell-tools-daemon@A response that tells there are errors in the source code given.Ahaskell-tools-daemonBInformation about changes that would be caused by the refactoring.Bhaskell-tools-daemonSThe traversal of the project is done, now the engine is loading the given modules.Chaskell-tools-daemon'The engine has loaded the given module.Dhaskell-tools-daemon2The result of querying the program representation.Ehaskell-tools-daemon2Returns the flags that are not used by the engine.Fhaskell-tools-daemon%The engine has closed the connection.Shaskell-tools-daemon&The messages expected from the client.Thaskell-tools-daemon:A simple ping message to check that the server is running.Uhaskell-tools-daemon\A message that instructs the server to reset its internal state and re-load loaded packages.Vhaskell-tools-daemon6Tells the client version and asks the servers version.Whaskell-tools-daemon0Sets the package database for the engine to use.Xhaskell-tools-daemonRegisters 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.Yhaskell-tools-daemoncDeregisters the given packages from the engine. They will not be subjects of further refactorings.Zhaskell-tools-daemon}Sets the working directory for the compilation. Important when compiling code that loads resources based on relative pathes.[haskell-tools-daemonXSets the compilation flags. The unused flags are returned via the UnusedFlags response.\haskell-tools-daemonOrders the engine to perform the refactoring on the module given with the selection and details. Successful refactorings will cause re-loading of modules. If l or ml is not set, after the refactoring, modules are re-loaded, LoadingModules, LoadedModule responses are sent.]haskell-tools-daemonXOrders the engine to perform a query on the module given with the selection and details.^haskell-tools-daemon-Asks the daemon to undo the last refactoring._haskell-tools-daemon/Stops the engine. It replies with Disconnected.`haskell-tools-daemonfInstructs the engine to re-load a changed module. LoadingModules, LoadedModule responses may be sent.ahaskell-tools-daemonStops the server. OBSOLATEkhaskell-tools-daemonPAdditional details for the refactoring like the names of generated definitions.lhaskell-tools-daemon1Stop the daemon after performing the refactoring.mhaskell-tools-daemon@Don't change the files, send back the result as a unified diff.I23456789:;<?=>@ABCDEFHOGIJKLMNPQRSUaTVWXYZ[\]^_`ikgbcdefhjlmnopqI23456789:;<?=>@ABCDEFHOGIJKLMNPQRSUaTVWXYZ[\]^_`ikgbcdefhjlmnopqNoneZ[|haskell-tools-daemon1An abstraction over the connection to the client.haskell-tools-daemonKConnect to the client running in a separate process using socket connectionhaskell-tools-daemonAConnect to the client running in the same process using a channel|}~|}~None"#<b1haskell-tools-daemon3This data structure identifies a module collection.haskell-tools-daemonAn alias for module nameshaskell-tools-daemonThe state of a module.haskell-tools-daemonjThe modules of a library, executable, test or benchmark. A package contains one or more module collection.haskell-tools-daemonHSets up the ghc environment for compiling the modules of this collectionhaskell-tools-daemon3Sets up the ghc environment for dependency analysis22None$NQV]i<haskell-tools-daemon}Extract module-related information from different kind of package components (library, executable, test-suite or benchmark).haskell-tools-daemon5Creates a key for registering this package component.haskell-tools-daemon3Gets the build info field from a package component.haskell-tools-daemon@Get the names of all the modules used by this package component.haskell-tools-daemontGets if some of the modules are defined is source files that are not in the expected location or named as expected.haskell-tools-daemonChecks 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.haskell-tools-daemonLGets the Main module in the case of executables, benchmarks and test suites.haskell-tools-daemon!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.haskell-tools-daemonSorts model collection in an order to remove all backward references. Works because module collections defined by directories cannot be recursive.haskell-tools-daemon 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.haskell-tools-daemonVLoad the module giving a directory. All modules loaded from the folder and subfolders.haskell-tools-daemonLoad 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.haskell-tools-daemonkA default method of getting the main module using the ghc-options field, checking for the option -main-is.haskell-tools-daemonJChecks if the module collection created from a folder without .cabal file.haskell-tools-daemonPModify the dynamic flags to match the dependencies requested in the .cabal file.haskell-tools-daemon_Only use the dependencies that are explicitely enabled. (As cabal does opposed to as ghc does.)haskell-tools-daemonSTransform dependencies of a module collection into the package flags of the GHC APIhaskell-tools-daemonSets 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 .haskell-tools-daemonCollects 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 .haskell-tools-daemonyCollects the compilation options and enabled extensions from Cabal's build info representation for a single module. See compileInContext. NoneV]haskell-tools-daemon!Handlers for generic exceptions: , , .haskell-tools-daemonlHint text and continuation suggestion for different kinds of errors based on pattern matching on error text.haskell-tools-daemonuHint text and continuation suggestion for different kinds of source problems based on pattern matching on error text. None"#$ haskell-tools-daemonxThe actual state of the daemon process. Contains loaded modules and user settings. The GHC state is handled separately.haskell-tools-daemon/The package components loaded into the session.haskell-tools-daemonKThe package database that is selected and a flag to decide if it is forced.haskell-tools-daemonCGHC flags for compiling modules. Overrides settings in cabal files.haskell-tools-daemon3The pathes where the package databases are located.haskell-tools-daemon4True if in the process of shutting down the session.haskell-tools-daemon4True if in the process of shutting down the session.haskell-tools-daemon0Information about the file system watch process.haskell-tools-daemonKExtra threads started for handling the information from the watch process.haskell-tools-daemonxMarks files as being modified by this process Changes detected on marked files will not invalidate refactoring history.haskell-tools-daemon%An initial state of a daemon session. None<QV haskell-tools-daemon0Get the name of a module collection from its Id.haskell-tools-daemonUFind the module collection where the given module is contained. Based on module name.haskell-tools-daemonZFind the module collection where the given module is contained. Based on source file name.haskell-tools-daemonjFind the module collection where the given module is contained. Based on source file name and module name.haskell-tools-daemon:Find the module with the given name. Based on module name.haskell-tools-daemon?Find the module with the given name. Based on source file name.haskell-tools-daemon7Get the module with the given name and source file key.haskell-tools-daemon:Remove a module with the given name. Based on module name.haskell-tools-daemonaRemove a module with the given name from a module collection. Based on module name and file path.haskell-tools-daemonCheck 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.haskell-tools-daemonMarks 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.haskell-tools-daemoncCheck if the given module has been already loaded. Based on both module name and source file name.haskell-tools-daemonQInsert a module with a source file key to our database if it wasn't there already   None<i# haskell-tools-daemonyLoad packages from the given directories. Loads modules, performs the given callback action, warns for duplicate modules.haskell-tools-daemon>Loads the packages that are declared visible (by .cabal file). haskell-tools-daemonJGet the module that is selected for refactoring and all the other modules. haskell-tools-daemonTReload the modules that have been changed (given by predicate). Pefrom the callback. haskell-tools-daemonClears 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. haskell-tools-daemonGet 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. haskell-tools-daemon*Reload a given module. Perform a callback.haskell-tools-daemon8Select which module collection we think the module is inhaskell-tools-daemon5Prepares the DynFlags for the compilation of a modulehaskell-tools-daemon4Prepares the DynFlags for travesing the module graphhaskell-tools-daemonFinds out if a newly added module forces us to generate code for another one. If the other is already loaded it will be reloaded.haskell-tools-daemonRe-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.haskell-tools-daemonCheck 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"#<N]i haskell-tools-daemon)Context for responding to a user request.haskell-tools-daemonfThis function does the real job of acting upon client messages in a stateful environment of a client.haskell-tools-daemonbUpdates the state of the tool after some files have been changed (possibly by another application)haskell-tools-daemon<Reloads changed modules to have an up-to-date version loadedhaskell-tools-daemon/Creates a compressed set of changes in one filehaskell-tools-daemoncCreates a unified-style diff of two texts. Only used when the user wants to know what would change.haskell-tools-daemonGUndo a refactoring change using the information that was saved earlier.haskell-tools-daemonOUndo the changes in one file using the information that was saved earlier. See .haskell-tools-daemon%Get the files added by a refactoring.haskell-tools-daemon'Get the files changed by a refactoring.haskell-tools-daemon'Get the files removed by a refactoring.None"#V haskell-tools-daemonStarts 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. haskell-tools-daemon;Stops the watch process and all threads associated with it.  None"#Vi!haskell-tools-daemonStarts 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."haskell-tools-daemonStarts 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.#haskell-tools-daemonlStarts the server loop, receiving requests from the client and updated the server state according to these.$haskell-tools-daemonOResponds to a client request by modifying the daemon and GHC state accordingly.!"#$!"#$ !"#$%&'()*+,-./012234567899:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuv7wxyz{|}~                                    ! " # $ % &'()*+,-./01201301401501601701801901:01;01<01=01>01?01@01A01B01C01D01E01F01G01H01I01J01K01L01M01N01O01P01Q01R01S01T01U01V01W01X01Y01Z01[01\01]01^01_01`01a01b01c01d01e01f01g01h01i01j01k01l01m01n01o01p01q01r01s01t01u01v01w01x01y01z01{01|01}01~010101010101010101010101010101010101010101010101010101010101010101013haskell-tools-daemon-1.1.0.2-HvUxGZDfRQk4g9VOwzVI3y&Language.Haskell.Tools.Daemon.Protocol+Language.Haskell.Tools.Daemon.MapExtensions)Language.Haskell.Tools.Daemon.ModuleGraph'Language.Haskell.Tools.Daemon.PackageDB%Language.Haskell.Tools.Daemon.Options"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.Daemon5haskell-tools-refactor-1.1.0.2-Gow74qwhN9O8QI7dzZUXUM(Language.Haskell.Tools.Refactor.QueryingmessageseveritylocationMarkerInfoWarningErrorSeveritysetExtensionFlag'unSetExtensionFlag'getModFromNodemoduleGraphNodessupportingModulesdependentModules $fOrdIsBoot $fEqIsBoot $fShowIsBoot $fReadIsBoot PackageDB DefaultDBCabalSandboxDBStackDB ExplicitDB packageDBPath decidePkgDB packageDBLoc detectAutogen$fFromJSONPackageDB $fEqPackageDB$fShowPackageDB$fGenericPackageDBSharedDaemonOptionsnoWatchwatchExe generateCodedisableHistoryghcFlags projectType DaemonOptions daemonVersion portNumber silentMode sharedOptionsparseDaemonCLIsharedOptionsParser$fShowSharedDaemonOptions$fShowDaemonOptionsFileDiff UndoRefactor RemoveAddedRestoreRemoved UndoChangesundoRemovePathundoRestorePathundoRestoreContentsundoChangedPathundoDiff ResponseMsgKeepAliveResponseHandshakeResponse ErrorMessageCompilationProblemDiffInfoLoadingModules LoadedModule QueryResult UnusedFlags Disconnected serverVersionerrorMsgmarkers errorHintsdiffInfo modulesToLoadloadedModulePathloadedModuleName queryName queryType queryResult unusedFlags ClientMessage KeepAliveReset Handshake SetPackageDB AddPackagesRemovePackages SetWorkingDir SetGHCFlagsPerformRefactoring PerformQueryUndoLast DisconnectReLoadStop clientVersionpkgDB addedPathes removedPathes newWorkingDir refactoring modulePatheditorSelectiondetails shutdownAfterdiffModequery addedModuleschangedModulesremovedModules$fFromJSONClientMessage$fToJSONResponseMsg$fToJSONUndoRefactor$fShowClientMessage$fGenericClientMessage$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 respondToghc-boot-th-8.4.3GHC.LanguageExtensions.Type ExtensionStrictOverlappingInstancesUndecidableInstancesIncoherentInstances RecursiveDoParallelListCompMultiParamTypeClassesMonomorphismRestrictionFunctionalDependencies RankNTypesExistentialQuantificationScopedTypeVariablesImplicitParamsFlexibleContextsFlexibleInstancesEmptyDataDeclsKindSignatures BangPatternsTypeSynonymInstancesTemplateHaskellForeignFunctionInterfaceArrowsImplicitPrelude PatternGuardsGeneralizedNewtypeDeriving MagicHash TypeFamiliesStandaloneDeriving UnicodeSyntaxUnliftedFFITypesInterruptibleFFICApiFFILiberalTypeSynonyms TypeOperatorsRecordWildCards RecordPunsDisambiguateRecordFieldsTraditionalRecordSyntaxOverloadedStringsGADTs GADTSyntax MonoPatBindsRelaxedPolyRecExtendedDefaultRules UnboxedTuplesDeriveDataTypeable DeriveGenericDefaultSignatures InstanceSigsConstrainedClassMethodsPackageImportsImpredicativeTypesPostfixOperators QuasiQuotesTransformListCompMonadComprehensions ViewPatterns TupleSectionsGHCForeignImportPrimNPlusKPatternsDoAndIfThenElse MultiWayIf LambdaCaseRebindableSyntaxExplicitForAllDatatypeContextsMonoLocalBinds DeriveFunctorDeriveTraversableDeriveFoldableNondecreasingIndentationConstraintKinds PolyKinds DataKindsParallelArraysRoleAnnotationsOverloadedLists EmptyCaseAutoDeriveTypeableNegativeLiteralsBinaryLiterals NumDecimalsNullaryTypeClassesExplicitNamespacesAllowAmbiguousTypes JavaScriptFFIPatternSynonymsPartialTypeSignaturesNamedWildCardsDeriveAnyClass DeriveLiftStaticPointers StrictData ApplicativeDoDuplicateRecordFieldsTypeApplications TypeInTypeUndecidableSuperClassesMonadFailDesugaringTemplateHaskellQuotesOverloadedLabelsTypeFamilyDependenciesDerivingStrategies UnboxedSumsHexFloatLiteralsCppAlternativeLayoutRule!AlternativeLayoutRuleTransitional RelaxedLayoutEmptyDataDeriving0Language.Haskell.Tools.Refactor.Utils.ExtensionstranslateExtension serializeExtcanonExtirregularExtensions impliedXFlagsturnOffturnOnreplaceDeprecatedexpandExtensionIsBootghc-prim GHC.TypesBoolhscSourceToIsBootghc DriverPhases HscSourcerunCommandExpectOKbaseGHC.IO.Exception IOExceptionAsyncException GHC.Exception SomeException UpdateCtx reloadModules createUndocreateUnifiedDiff performUndoperformUndoChanges getUndoAddedgetUndoChangedgetUndoRemoved