!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred +36:HMNone+36:HMRPC server stateBThe server was stopped, either manually or because of an exceptionThe server is running.+Abstract data type representing RPC serversHandle to write requests to;Temporary file the server will write uncaught exceptions to#Handle on the server process itself<This is Nothing if we connected to an existing RPC server (%) rather than started a new server ()+IORef containing the server response stream Server state0Identity of this server (for debugging purposes)(Fork an RPC server as a separate processforkRpcServer exec args starts executable exec with arguments  args ++ args' where args'& are internal arguments generated by =. These internal arguments should be passed as arguments to  rpcServer.%As a typical example, you might pass  ["--server"] as args , and the main function of exec might look like main = do args <- getArgs case args of "--server" : args' -> rpcServer args' <<your request handler>> _ -> <<deal with other cases>>!Connect to an existing RPC servervIt is the responsibility of the caller to make sure that each triplet of named pipes is only used for RPC connection.Specialized form of 6 to do single request and wait for a single response.nRun an RPC conversation. If the handler throws an exception during the conversation the server is terminated.Shut down the RPC serverThis simply kills the remote process. If you want to shut down the remote process cleanly you must implement your own termination protocol before calling .Force shutdown.In order to faciliate a force shutdown while another thread may be communicating with the RPC server, we _try_ to update the MVar underlying the RPC server, but if we fail, we terminate the server anyway. This means that this may leave the Z in an invalid state -- so you shouldn't be using it anymore after calling forceShutdown!Terminate the RPC connectionIf we connected using  (rather than /) we wait for the remote process to terminate.$Force-terminate the external processCThrows an exception when we are connected to an existing RPC server7Like modifyMVar, but terminate the server on exceptions:Get the exit code of the RPC server, unless still running.<Thross an exception for connections to existing RPC servers.YMap IO exceptions to external exceptions, using the error written by the server (if any)Filename of the executable ArgumentsWorking directory Environmentstdin named pipestdout named pipelogfile for storing exceptionsNone +36:HM gConfiguration parameters for a session. These remain the same throughout the whole session's lifetime. +The directory to use for all session files. _Extra directories in which to look for programs, including ghc and other tools. Note that the $PATH is still searched first, these directories are extra. TShould the GHC client run in-process? NOTE: This is currently broken. Set to False.4Whether to generate module type/autocompletion info.Package DBs to consultPackages that don't need the .cabal files provided for license concatenation (e.g., because they are covered by the core license set).Hard-coded package licence information, e.g., for the packages that always stay installed in-place in the GHC tree, so it's troublesome to automatically retrieve their .cabal files.tFunction to be used for logging. Messages logged in this manner may be provided to users in a special debugging UI.iDelete temporary files when session finishes? (Defaults to True; mostly for internal debugging purposes)Default session configurationfUse this instead of creating your own SessionConfig to be robust against extensions of SessionConfig. defaultSessionConfig = SessionConfig { configDir = "." , configExtraPathDirs = [] , configInProcess = False , configGenerateModInfo = True , configPackageDBStack = [GlobalPackageDB, UserPackageDB] -- ghc-prim, integer-gmp, etc., all have their own licenses specified -- in their .cabal files. , configLicenseExc = ["rts"] , configLicenseFixed = [ ("bin-package-db", (Just BSD3, Nothing, Nothing)) , ("ghc", (Just BSD3, Just "../LICENSE", Just "The GHC Team")) , ("ghc-prim", (Just BSD3, Just "LICENSE", Nothing)) , ("integer-gmp", (Just BSD3, Just "LICENSE", Nothing)) ] , configLog = const $ return () , configDeleteTempFiles = True }   None +36:HM'VHandles to the running code snippet, through which one can interact with the snippet. Requirement: concurrent uses of  supplyStdin5 should be possible, e.g., two threads that share a  RunActions` should be able to provide input concurrently without problems. (Currently this is ensured by  supplyStdin writing to a channel.)2Wait for the code to output something or terminate*Send a UserInterrupt exception to the code A call to 0 after the snippet has terminated has no effect.'Make data available on the code's stdin A call to 0 after the snippet has terminated has no effect.`Force terminate the runaction (The server will be useless after this -- for internal use only).Guranteed not to block.GMapping from C files to the corresponding .o files and their timestamps>The collection of source and data files submitted by the user.A workaround for http:/hackage.haskell.orgtracghcGticket/7473. Logical timestamps (used to force ghc to recompile files)VThe result computed by the GHC API typing/compilation invocation in the last call to  updateSession invocation.Current GHC options#Include paths (equivalent of GHC's -i parameter) relative to the temporary directory where we store the session's source files. The initial value, used also for server startup, is taken from configRelativeIncludes.&By default this is the singleton list [""]r -- i.e., we include the sources dir (located there in simple setups, e.g., ide-backend tests) but nothing else. 6Whether to generate code in addition to type-checking. 0Files submitted by the user and not deleted yet. "Object files created from .c files &Exit status of the last invocation of buildExe , if any. &Exit status of the last invocation of buildDoc , if any.&Exit status of the last invocation of buildDoc , if any.Environment overrides7Command line arguments for snippets (expected value of getArgs)$The GHC server (this is replaced in restartSession) GHC version$Buffer mode for standard output for runStmt#Buffer mode for standard error for runStmt!Are we currently in a breakpoint?Targets for compilation6RTS options (for the ghc session, not for executables) Configuration'(Temporary) directory for session files See also: * ideSessionSourceDir * ideSessionDataDir, * ideSessionDistDirThis type is a handle to a session state. Values of this type point to the non-persistent parts of the session state in memory and to directories containing source and data file that form the persistent part of the session state. Whenever we perform updates or run queries, it's always in the context of a particular handle, representing the session we want to work within. Many sessions can be active at once, but in normal applications this shouldn't be needed.Last compilation and run errorsModules that got loaded okay1Mapping from filepaths to the modules they define]Import information. This is (usually) available even for modules with parsing or type errorsAutocompletion mapCMapping, per module, from prefixes to fully qualified names I.e., fo might map to Control.Monad.forM, Control.Monad.forM_ etc. (or possibly to M.forM, M.forM_4, etc when Control.Monad was imported qualified as M).*Information about identifiers/quasi-quotes %Type information about subexpressions! Use sites"!(Transitive) package dependencies#/We access IdProps indirectly through this cacheR$%&'()*+,     -./012345678 !"#9:;<=>?@ABCDEFGHIJKLMQ$%&'()*+,     -./012345678 !"#9:;<=>?@ABCDEFGHIJKLM $&%'()*+,     -.10/234567 8 !"#9:;<=>?@ABCDEFGHIJKLMNone+36:EHM NStart the ghc serverRepeatedly call  until we receive a O result, while collecting all P resultsQSet the environmentRSet command line argumentsSSet ghc optionsTCompile or typecheckUSet breakpointReturns Just. the old value of the break if successful, or Nothing' if the breakpoint could not be found.VRun code(NOTE: This is an interruptible operationWPrint a variableXLoad an object fileYUnload an object fileZ-Crash the GHC server (for debugging purposes)[Handshake with the server\]^_NInitial ghc optionsRelative includes RTS optionsSession setup info`abQRST GHC serverShould we generate code?TargetsProgress callbackUV GHC server Run commandTranslate run results Nothing indicates force cancellationWXYZ[cde$%&NabQRSTUVWXYZ\_^]N`abQRSTUVWXYZ[cdeNone +36:HM#3 fields from session configuration:the working directory; the resulting file is written theresee configLicenseFixed'the directory with all the .cabal filesthe list of packages to processQBuild the concatenation of all license files from a given list of packages. See  buildLicenses.fJRun gcc via ghc, with correct parameters. Copied from bits and pieces of Distribution.Simple.GHC.Ighijklmnopqrstuvwxyz{|}~f3ghijklmnopqrstuvwxyz{|}~f#gihjnmlk o pqrstuvwxyz{ |}~fNone +36:HM!>The collection of source and data files submitted by the user.-The type of queries in a given session state.Queries are in IO because they depend on the current state of the session but they promise not to alter the session state (at least not in any visible way; they might update caches, etc.).:Recover the fixed config the session was initialized with.3Obtain the source files directory for this session.1Obtain the data files directory for this session.}Obtain the directory prefix for results of Cabal invocations. Executables compiled in this session end up in a subdirectory build, haddocks in doc , concatenated licenses in file licenses, etc.4Read the current value of one of the source modules.0Read the current value of one of the data files.Get the list of all data files currently available to the session: both the files copied via an update and files created by user code.%Is code generation currently enabled?%Get all current environment overridesGet all current snippet args'Get the RPC server used by the session.0Which GHC version is `ide-backend-server` using?Get the collection of files submitted by the user and not deleted yet. The module names are those supplied by the user as the first arguments of the updateSourceFile and updateSourceFileFromFile- calls, as opposed to the compiler internal module ... endE module names. Usually the two names are equal, but they needn't be.*Get exit status of the last invocation of buildExe , if any.*Get exit status of the last invocation of buildDoc , if any.*Get exit status of the last invocation of  buildLicenses , if any.5Get information about the last breakpoint that we hit@Returns Nothing if we are not currently stopped on a breakpoint.Get any compilation errors or warnings in the current state of the session, meaning errors that GHC reports for the current state of all the source modules.,Note that in the initial implementation this will only return warnings from the modules that changed in the last update, the intended semantics is that morally it be a pure function of the current state of the files, and so it would return all warnings (as if you did clean and rebuild each time).getSourceErrors does internal normalization. This simplifies the life of the client and anyway there shouldn't be that many source errors that it really makes a big difference.GGet the list of correctly compiled modules, as reported by the compiler>Get the mapping from filenames to modules (as computed by GHC):Get information about an identifier at a specific locationNGet information the type of a subexpressions and the subexpressions around itGet import informationEThis information is available even for modules with parse/type errorsAutocompletionUse w to translate these m@s into qualified names, taking into account the module imports.!(Transitive) package dependenciesDThese are only available for modules that got compiled successfully. Use sitesFUse sites are only reported in modules that get compiled successfully.nMinimal .cabal file for the loaded modules seen as a library. The argument specifies the name of the library.License is set to AllRightsReserved . All transitive package dependencies are included, with package versions set to the currently used versions. Only modules that get compiled successfully are included. Source directory is the currently used session source directory. Warning: all modules named Main (even in subdirectories or files with different names) are ignored so that they don't get in the way when we build an executable using the library and so that the behaviour is consistent with that of buildExe.>Print the id info maps to stdout (for debugging purposes only)<Print autocompletion to stdout (for debugging purposes only):Print file mapping to stdout (for debugging purposes only)1For the purposes of queries, we pretend that the /= state is a regular state, but we report the exception as a 8.&* None +36:HM Delete a fileCCopy a local file (the FilePath is interpreted as an absolute path)Write a file from a bytestring*Declarative description of session updates_IdeSessionUpdate forms a monoid, which is right-biased: "later" calls override "earlier" ones: (updateTargets targets1 <> updateTargets2is equivalent to updateTargets2\However, updates of a different nature are not necessarily executed in order; for instance, 0updateDynamicOpts opts <> updateSourceFile fp bsis equivalent to 0updateSourceFile fp bs <> updateDynamicOpts optsCIn both cases options are set before new source files are compiled.+File commands are updated in order, so that 1updateSourceFile fp bs <> updateSourceFile fp bs'is equivalent to updateSourceFile fp bs'?which is consistent with "later updates override earlier ones".2Delete all files currently managed in this sessionA session update that changes a source file by providing some contents. This can be used to add a new module or update an existing one. The FilePath argument determines the directory and file where the module is located within the project. In case of Haskell source files, the actual internal compiler module name, such as the one given by the getLoadedModules query, comes from within module ... end8. Usually the two names are equal, but they needn't be.Like x except that instead of passing the source by value, it's given by reference to an existing file, which will be copied.6A session update that deletes an existing source file.A session update that changes a data file by giving a new value for the file. This can be used to add a new file or update an existing one.Like  except that instead of passing the file content by value, it's given by reference to an existing file (the second argument), which will be copied.Deletes an existing data file.Set ghc optionsqThis function is stateless: the set of actions options is the set provided by the last call to updateGhcOptions.FSet RTS options for the ghc session (this does not affect executables)"This will cause a session restart.ENOTE: Limiting stack size does not seem to work for ghc 7.4 (https:/ github.comfpco ide-backend issues/258).'Set include paths (equivalent of GHC's -i parameter). In general, this requires session restart, because GHC doesn't revise module dependencies when targets or include paths change, but only when files change.This function is stateless: semantically, the set of currently active include paths are those set in the last call to updateRelativeIncludes. Any paths set earlier (including those from configRelativeIncludesH) are wiped out and overwritten in each call to updateRelativeIncludes.MEnable or disable code generation in addition to type-checking. Required by runStmt.Set environment variablesUse updateEnv [(var, Nothing)] to unset var.+Note that this is intended to be stateless:  updateEnv []@will reset the environment to the server's original environment.FSet command line arguments for snippets (i.e., the expected value of getArgs)'Set buffering mode for snippets' stdout'Set buffering mode for snippets' stderrSet compilation targets. In general, this requires session restart, because GHC doesn't revise module dependencies when targets or include paths change, but only when files change.{Build an exe from sources added previously via the ide-backend updateSourceFile* mechanism. The modules that contains the main+ code are indicated in second argument to buildExe. The function can be called multiple times with different arguments. Additional GHC options, applied only when building executables, are supplied in the first argument.nWe assume any indicated module is already successfully processed by GHC API in a compilation mode that makes computedImports available (but no code needs to be generated). The environment (package dependencies, ghc options, preprocessor program options, etc.) for building the exe is the same as when previously compiling the code via GHC API. The module does not have to be called Main,, but we assume the main function is always mainf (we don't check this and related conditions, but GHC does when eventually called to build the exe).=The executable files are placed in the filesystem inside the build subdirectory of  , in subdirectories corresponding to the given module names. The build directory does not overlap with any of the other used directories and with its path.3Logs from the building process are saved in files build/ide-backend-exe.stdout and build/ide-backend-exe.stderr in the   directory.Note: currently it requires configGenerateModInfoD to be set (see #86). Also, after session restart, one has to call  updateSessionE at least once (even with empty updates list) before calling it for buildExeK. This ensures the code is compiled again and the results made accessible.yBuild haddock documentation from sources added previously via the ide-backend updateSourceFile* mechanism. Similarly to t, it needs the project modules to be already loaded within the session and the generated docs can be found in the doc subdirectory of  .ALogs from the documentation building process are saved in files doc/ide-backend-doc.stdout and doc/ide-backend-doc.stderr in the   directory.Note: currently it requires configGenerateModInfo to be set (see #86).EBuild a file containing licenses of all used packages. Similarly to , the function needs the project modules to be already loaded within the session. The concatenated licenses can be found in file  licenses.txt inside the   directory.SThe function expects .cabal files of all used packages, except those mentioned in configLicenseExcK, to be gathered in the directory given as the first argument (which needs to be an absolute path or a path relative to the data dir). The code then expects to find those packages installed and their license files in the usual place that Cabal puts them (or the in-place packages should be correctly embedded in the GHC tree).We guess the installed locations of the license files on the basis of the haddock interfaces path. If the default setting does not work properly, the haddock interfaces path should be set manually. E.g., >cabal configure --docdir=the_same_path --htmldir=the_same_path~ affects the haddock interfaces path (because it is by default based on htmldir) and is reported to work for some values of  the_same_path.HLogs from the license search and catenation process are saved in files licenses.stdout and licenses.stderr in the   directory.Note: currently configGenerateModInfo6 needs to be set for this function to work (see #86).8Note: if the executable uses TH and its module is named Main? (and so it's not compiled as a part of a temporary library)   needs to be set. See #162..,None+36:EHMgInvoke the executable that processes our custom functions that use the machinery of the cabal library.None+2346:BHM Kind of like , but with a special treatment for external exceptions. When the IO action throws an ExternalException, _or_ when a previous IO exception threw an ExternalException, we return a dummy value and record the exception separately. Thus, for an action of type  foo :: IO ()lwe will return () on an exception, as if the action returned successfully; similarly, for an action of type bar :: IO [SourceError]we will return the empty list on an exception. The rationale is that if ExternalException occurs, we will eventually record the session as dead (in the top-level updateSession function), but everything else in the execution of the session update should still happen (#251).NOTE: We deal _only_ with external exceptions here. Any other kind of exception should be explicitly caught and dealt with by the IO action.For code that we _know_ is exception free we can just execute the action. Of course, this needs manual verification that these cases are actually okay. If the action _does_ throw an exception this may end the session update prematurely.Execute a session updateNotes:We do NOT deal with updates there that require a session restart (updates to relative includes, targets, certain ghc options).AThe assume the session update has already been passed through % to reflect the state of the session.Due to the MonadState instance, writes to the state will be preserved even if an exception occurs during the execution of the session update. Such exceptions should only happen when we contact the server (do RPC calls); it is therefore important we make sure to update our local state before updating the rmote state, so that _if_ a remote exception occurs, we can reset the state on the next call to updateSession..Remove context sensitivty from session updatesSome updates (such as ideUpdateDeleteFiles) are context sensitive: their meaning depends on the state of the session when the update is performed. For these updates we "reflect" the current state of the session once, just before we execute the update.Execute file update commands+Returns whether any files actually changed.~We share the directory where the files are stored with the server, so we don't need to explicitly send over any changed filesEnable/disable code gen7Returns if code gen was enabled (and wasn't previously)pEnabling/disabling code generation has no effect on the server, as we pass this flag on each call to rpcCompileUpdate buffer modesUpdating buffer modes is local only, because we pass the required buffer mode on each and every call to runStmt, rather than setting a server side flagUpdate server environmentUpdate snippet argumentsUpdate ghc optionsaReturns Just a (possibly empty) set of a warnings if options were changed, or Nothing otherwise.We don't deal with setting relative includes here: this always requires a session restart; similarly, we assume that if any of the changed options require a session restart that this has already happened.eRecompile any C files that need recompiling and mark all Haskell modules that require recompilation.fReturns the number of actions that were executed, so we can adjust Progress messages returned by ghc..Figure out which C files need to be recompiled6Call gcc via ghc, with the same parameters cabal uses.(Force recompilation of the given modulesNOTE: Calling markAsUpdated _by itself_ is not sufficient to call a recompile of these files, as executeSessionUpdate needs some additional information to even ask ghc for a recompile at all (see needsRecompile). Currently we use T after we (re)compile C files, which executeSessionUpdate is told about separately.+TODO: Should we update data files here too?Execute a file commandReturns  if any files were changed.6TODO: We should verify each use of exceptionFree here.GUpdate the file times of the given file with the next logical timestamp(Get the next available logical timestampUnload all current object filesReload all current object files3+None+36:BHM&How should the session be initialized?Client code should use = to protect itself against future extensions of this record.&Previously computed cabal macros, or  to compute them on startupInitial ghc options#Include paths (equivalent of GHC's -i[ parameter) relative to the temporary directory where we store the session's source files.&By default this is the singleton list [""]7 -- i.e., we include the sources dir but nothing else.Targets for compilation Defaults to TargetsExclude []. -- i.e., compile all modules in the project. RTS options Defaults to -K8M:Session initialization parameters for an existing session.For internal use only (used in  when restarting the session).We set  to  because the cabal macros file has already been written to disk, and we don't remove the project directory on a session restart.ISet up the initial state of the session according to the given parametersWrite per-package CPP macros.9Create a fresh session, using some initial configuration.TThrows an exception if the configuration is invalid, or if GHC_PACKAGE_PATH is set.HVerify configuration, and throw an exception if configuration is invalid.Close a session down, releasing the resources.This operation is the only one that can be run after a shutdown was already performed. This lets the API user execute an early shutdown, e.g., before the shutdownSession placed inside bracket0 is triggered by a normal program control flow.1If code is still running, it will be interrupted.:Like shutdownSession, but don't be nice about it (SIGKILL)Internal generalization of  and Restart a sessionbThis puts the session in a "dead" state; it won't _actually_ be restarted until the next call to .Given the current IDE session state, go ahead and update the session, eventually resulting in a new session state, with fully updated computed information (typing, etc.).}The update can be a long running operation, so we support a callback which can be used to monitor progress of the operation.requiresSessionRestart st upd returns true if update upd1 requires a session restart given current state st.See G to compute the session initialization parameters for the new session.listChanges xs ys( is the list of elements that appear in xs but not in ys( and the set of elements that appear in ys but not in xs.^Considering the lists as sets, it is the complement of the intersection between the two sets.SRun a given function in a given module (the name of the module is the one between module ... end, which may differ from the file name). The function resembles a query, but it's not instantaneous and the running code can be interrupted or interacted with. will throw an exception if the code has not been compiled yet, or when the server is in a dead state (i.e., when ghc has crashed). In the latter case getSourceErrors_ will report the ghc exception; it is the responsibility of the client code to check for this.8Run the main function from the last compiled executable. will throw an exception if there were no executables compiled since session init, or if the last compilation was not successful (checked as in getBuildExeStatus) or if none of the executables last compiled have the supplied name or when the server is in a dead state (i.e., when ghc has crashed). In the last case getSourceErrors_ will report the ghc exception; it is the responsibility of the client code to check for this.)Resume a previously interrupted statement"Internal geneneralization used in  and  Breakpoint4Set a breakpoint at the specified location. Returns Just4 the old value of the breakpoint if successful, or Nothing otherwise.*Print and/or force values during debuggingOnly valid in breakpoint state.ECrash the GHC server. For debugging only. If the specified delay is Nothingm, crash immediately; otherwise, set up a thread that throws an exception to the main thread after the delay.'   *Module where the breakshould should be setLocation of the breakpointNew value for the breakpoint&Old value of the breakpoint (if valid)Variable to print Should printing bind new vars? (:print vs. :sprint)Should the value be forced? (:print vs. :force)  3     None +36:HM  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ~}y|z{>:9;<=DABC?@?vutrsq)'(&"%#$mlkjihdcbfgea`^_]Z[\321/0-.pon87645 !MLKJIHFEGQNOPYXTSRUWV,+*wx !"#$%&'()*)+),)-./.012131415161718191:1;1<1=1>1?1@1A1B1C1D1E1F1G1H1H1I1J1K1L1L1M1N1O1P1Q1R1S1T1U1V1W1X1Y1Z1[1\1\1]1^1_1_1`1a1b1c1d1e1f1g1h1i1j1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1y1z1{1|1|1}1~111111111          !"#$%&'(')*+,--./012334566789:;<=>?@ABCDEFGHIJKLMNOMNPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxyzz{|}~                          TQRSM    ide-backend-0.9.0.2 IdeSessionIdeSession.LicensesIdeSession.RPC.ClientIdeSession.ConfigIdeSession.StateIdeSession.GHC.ClientIdeSession.CabalIdeSession.Query"IdeSession.Update.IdeSessionUpdateQuery getDistDirConfig configDynLinkIdeSession.ExeCabalClient&IdeSession.Update.ExecuteSessionUpdateIdeSession.Updateide-backend-common-0.9.0IdeSession.RPC.APIexternalStdErrexternalExceptionExternalExceptionCabal-ide-backend-1.23.0.0Distribution.Simple.CompilerPackageDBStack UserPackageDBSpecificPackageDBGlobalPackageDB PackageDB SessionConfig configDirconfigExtraPathDirsconfigInProcessconfigGenerateModInfoconfigPackageDBStackconfigLicenseExcconfigLicenseFixed configLogconfigDeleteTempFiles InProcessdefaultSessionConfigIdeSession.GHC.ResponsesGHC_7_8GHC_7_4GHC_7_10 GhcVersionIdeSession.GHC.APIsourceExtensionsideBackendApiVersionIdeSession.Types.PublicType KindWarningKindServerDied KindErrorSourceErrorKind ModuleNameVarNameTvName TcClsNameDataName IdNameSpaceTargetsIncludeTargetsExcludeTargetsSpanQQSpanIdSpanInfo spanToLine spanToColumn spanFromLinespanFromColumn spanFilePath SourceSpan errorSpanerrorMsg errorKind SourceErrorRunProgExceptionRunOkRunGhcExceptionRunForceCancelledRunBreak RunResultrunBufferTimeoutrunBufferBlockSizeRunNoBufferingRunLineBufferingRunBlockBuffering RunBufferModepackageVersion packageName packageKey PackageId modulePackage moduleNameModuleId ImportOnly ImportHiding ImportAllImportEntitiesimportQualified importPackage importModuleimportImplicitimportEntitiesimportAsImportidImportedFrom idImportSpan idImportQualWiredInLocalImportedBinderIdScopeidTypeidSpaceidName idHomeModule idDefinedIn idDefSpanIdPropidScopeidPropIdInfoTextSpan ProperSpan EitherSpanbreakInfoVariableEnv breakInfoSpanbreakInfoResultTypebreakInfoModule BreakInfoidInfoQN haddockLinkIdeSession.Types.Progress progressStepprogressParsedMsgprogressOrigMsgprogressNumStepsProgress RunActionsrunWait interrupt supplyStdin forceCancelgetGhcExitCode runWaitAll LicenseArgsliPackageDBStackliExtraPathDirs liLicenseExc liDistDir liStdoutLog liStderrLog licenseFixed liCabalsDirliPkgsbuildLicsFromPkgsInvalidSessionStateQueries ManagedFiles sourceFiles dataFilesgetSessionConfig getSourcesDir getDataDirgetSourceModule getDataFilegetAllDataFilesgetCabalMacrosgetCodeGenerationgetEnv getGhcServer getGhcVersiongetManagedFilesgetBuildExeStatusgetBuildDocStatusgetBuildLicensesStatus getBreakInfogetSourceErrorsgetLoadedModules getFileMap getSpanInfo getExpTypes getImportsgetAutocompletion getPkgDeps getUseSites getDotCabal dumpIdInfodumpAutocompletion dumpFileMapIdeSessionUpdateupdateDeleteManagedFilesupdateSourceFileupdateSourceFileFromFileupdateSourceFileDeleteupdateDataFileupdateDataFileFromFileupdateDataFileDelete updateGhcOpts updateRtsOptsupdateRelativeIncludesupdateCodeGeneration updateEnv updateArgsupdateStdoutBufferModeupdateStderrBufferMode updateTargetsbuildExebuildDoc buildLicensesSessionInitParamssessionInitCabalMacrossessionInitGhcOptionssessionInitRelativeIncludessessionInitTargetssessionInitRtsOptsdefaultSessionInitParams initSessionshutdownSessionforceShutdownSessionrestartSession updateSessionrunStmtrunExeresume setBreakpointprintVarcrashGhcServerLicensebsd3gplv2gplv3lgpl2lgpl3apache20RpcClientSideState RpcStopped RpcRunning RpcServer rpcRequestW rpcErrorLogrpcProcconnectToRpcServer forkRpcServer rpcResponseRrpcState rpcIdentityrpcrpcConversationshutdown forceShutdown terminateforceTerminate withRpcServergetRpcExitCodemapIOToExternalillscopedConversationExceptionputgetRpcConversationserverKilledException ObjectFilesManagedFilesInternal_ideLogicalTimestamp _ideComputed _ideGhcOpts_ideRelativeIncludes_ideGenerateCode_ideManagedFiles_ideObjectFiles_ideBuildExeStatus_ideBuildDocStatus_ideBuildLicensesStatus_ideEnv_ideArgs _ideGhcServer_ideGhcVersion_ideStdoutBufferMode_ideStderrBufferMode _ideBreakInfo _ideTargets _ideRtsOpts ideConfig ideSessionDircomputedErrorscomputedLoadedModulescomputedFileMapcomputedImportscomputedAutoMapcomputedSpanInfocomputedExpTypescomputedUseSitescomputedPkgDeps computedCache GhcServer OutProcess ManagedFile_managedSource _managedData IdeIdleStateLogicalTimestampIdeSessionStateIdeSessionServerDiedIdeSessionShutdownIdeSessionIdle IdeStaticInfo ideStaticInfoideStateComputedideLogicalTimestamp ideComputed ideGhcOptsideRelativeIncludesideGenerateCodeideManagedFilesideObjectFilesideBuildExeStatusideBuildDocStatusideBuildLicensesStatusideEnvideArgs ideGhcServer ideGhcVersionideStdoutBufferModeideStderrBufferMode ideBreakInfo ideTargets ideRtsOpts managedSource managedData forkGhcServerbase Data.EitherRightLeft rpcSetEnv rpcSetArgs rpcSetGhcOpts rpcCompile rpcBreakpointrpcRunrpcPrintrpcLoad rpcUnloadrpcCrashrpcInit SnippetActionSnippetForceTerminatedSnippetTerminated SnippetOutputsplitPackageDBStackshutdownGhcServerforceShutdownGhcServerghcConversationghcRpcignoreIOExceptionsrunComponentCcExeCabalResponse ExeCabalDoneExeCabalProgressExeCabalRequest ReqExeLicReqExeCc ReqExeDoc ReqExeBuild RunCcArgsrcPackageDBStackrcExtraPathDirs rcDistDir rcStdoutLog rcStderrLogrcAbsCrcAbsObjrcPref rcIncludeDirs rcOptions BuildExeArgsbePackageDBStackbeExtraPathDirs beSourcesDir beDistDir beStdoutLog beStderrLogbeRelativeIncludes beGhcOpts beLibDeps beLoadedMs pkgNameMainpkgVersionMainpkgDescFromNamepkgDescbInfo getCSources getCHeadersexeDesclibDescparseVersionString externalDeps mkConfFlagsconfigureAndBuildconfigureAndHaddock buildDotCabal lFieldDescrs buildDeps licenseTextgetYeargenerateMacrosdefaultProgramConfigurationlocalBuildInfo$fBinaryExitCode$fBinaryLicenseArgs$fBinaryRunCcArgs$fBinaryBuildExeArgs$fBinaryExeCabalResponse$fBinaryExeCabalRequestgetArgs withIdleStateinternalGetSpanInfowithComputedState staticQuery simpleQuery computedQuery%$fExceptionInvalidSessionStateQueries $fShowInvalidSessionStateQueries FileDeleteFileCopy FileWriteFileCmdFileInfofileInfoRemoteDirfileInfoRemoteFilefileInfoAccessorideUpdateFileCmdsideUpdateDeleteFilesideUpdateGhcOptsideUpdateRelInclsideUpdateCodeGen ideUpdateEnv ideUpdateArgsideUpdateStdoutModeideUpdateStderrModeideUpdateTargets ideUpdateExes ideUpdateDocsideUpdateLicensesideUpdateRtsOpts$fShowFileInfo$fMonoidIdeSessionUpdateinvokeExeCabalrpcRunExeCabaltryIOtransformers-0.3.0.0Control.Monad.IO.ClassliftIO exceptionFreeexecuteSessionUpdatereflectSessionStateexecuteUpdateFilesexecuteUpdateCodeGenexecuteUpdateBufferModesexecuteUpdateEnvexecuteUpdateArgsexecuteUpdateGhcOptsupdateObjectFilesoutdatedObjectFilesrunGcc markAsUpdatedexecuteFileCmdghc-prim GHC.TypesTrueupdateFileTimesnextLogicalTimestamprpcUnloadObjectFilesrpcLoadObjectFilesDummydummyExecuteSessionUpdate unwrapUpdateIdeSessionUpdateEnvideUpdateStaticInfoideUpdateCallbackideUpdateStateRefideUpdateExceptionRefrunSessionUpdateremoveObsoleteObjectFilesrecompileCFilesexecuteBuildExeexecuteBuildDocexecuteBuildLicensesmaybeSet$fDummyGhcCompileResult$fDummyExplicitSharingCache $fDummyStrict$fDummyStrict0$fDummyStrict1 $fDummyMaybe $fDummy(,) $fDummy[] $fDummy(),$fMonadStateIdeIdleStateExecuteSessionUpdate Data.MaybeNothingsessionRestartParamsexecInitParams writeMacros verifyConfigshutdownSession'requiresSessionRestart listChangesrunCmd RestartResultServerRestartFailedServerRestartedcheckPackageDbEnvVarexecuteRestartupdateSession' withBreakInfomodifyIdleStatefailedToRestart forcedRestartserverRestartLoop