!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~" Safe-Inferred +2346:HM  None +36:HMNone!"+36:HM Safe-Inferred +36:HMNone +36:HM&Exceptions thrown by the remote server$The output from the server on stderrAThe local exception that was thrown and alerted us to the problemEGeneric exception thrown if the server gets killed for unknown reason(Write a bytestring to a buffer and flushIgnore IO exceptionsOpen a pipe for writing'This is meant to be used together with Open a pipe for reading'This is meant to be used together with                 Safe-Inferred +36:HM  !"#$%&'( )*+,"#$%&  !"#$%&'( Safe-Inferred +36:HM-./0123-./0123-./0123  Safe-Inferred +36:HM456789:;<=>?@A 46789:;<=>?@A 456789:;<=>?@A None +36:HMBCDEFGHIJKLMNOPQRSTUVWXBCDEFGHIJKLMNOPQRSTUVWXBCDEFGHIJKLMNOPQRSTUVWX None*+2346:=HKM$YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~YZ[\]^_`abcdefYZ[\gih]^jklmnpo_`qrtsabuvxwcdyz|{ef None +-36:HM None+-./36:HM   None +36:HMLeft biased unionNone*+-036:BHM:Show an exception together with its most precise type tag.Translate record field _name to the accessor namePrelude.lookup as an accessorWrites a file atomically.nThe file is either written successfully or an IO exception is raised and the original file is left unchanged.On windows it is not possible to delete a file that is open by a process. This case will give an IO exception but the atomic property is not affected.Returns the hash of the file; we are careful not to force the entire input bytestring into memory (we compute the hash as we write the file). makeBlocks nD splits a bytestring into blocks with a size that is a multiple of n3, with one left-over smaller bytestring at the end.Based from the (unexported)  in the crypto-api package, but we are careful to be as lazy as possible (the first -- block can be returned before the entire input bytestring is forced)cFirst restore the environment to the specified initial environment, then apply the given overrides!Ignore "does not exist" exceptionDefine interruptiple operations'(TODO: Stick in reference to blog post)None+2346:=HKM   None +36:HMNone +036:HM,.Variables during execution (in debugging mode)-We present values only in pretty-printed form(Information about a triggered breakpoint  Module containing the breakpoint Location of the breakpoint Type of the result  Local variables and their values The outcome of running code,Execution was paused because of a breakpointThe session was restarted;GHC itself threw an exception when we tried to run the codeThe code threw an exceptionThe code terminated okayBuffer modes for running code Note that  NoBuffering means that something like  will do a syscall per character, and each of these characters will be read and sent back to the client. This results in a large overhead. When using  LineBuffering or BlockBuffering, runWait will not report any output from the snippet until it outputs a linebreak/fills the buffer, respectively (or does an explicit flush). However, you can specify a timeout in addition to the buffering mode; if you set this to Just n$, the buffer will be flushed every n microseconds.ENOTE: This is duplicated in the IdeBackendRTS (defined in IdeSession)@Returned then the IDE asks "what's at this particular location?"Quasi-quote. The V field gives the quasi-quoter Identifier,Used only for ghc's PackageImports extension(A package ID in ide-backend consists of a human-readable package name and version (what Cabal calls a source ID) along with ghc's internal package key (primarily for internal use).2Severity of an error.6'An error or warning in a source module.UMost errors are associated with a span of text, but some have only a location point.FWired into the compiler ((), True, etc.)G Imported from a different moduleJQualifier used for the import IMPORTED AS idImportQual import Data.List "" import qualified Data.List "Data.List." import qualified Data.List as L "L."KDefined within this moduleLThis is a binding occurrence (f x = .., x -> .., etc.)M5Identifier info that is independent of the usage siteOPThe base name of the identifer at this location. Module prefix is not included.P'Namespace this identifier is drawn fromQThe type We don't always know this; in particular, we don't know kinds because the type checker does not give us LSigs for top-level annotations)R$Module the identifier was defined inS5Where in the module was it defined (not always known)THaddock home moduleU1For now we represent types in pretty-printed form Variable nameVInformation about identifiersZGIdentifiers in Haskell are drawn from a number of different name spaces[Type constructors and classes\Type variables]Source data constructors^+Variables, including real data constructors_:Construct qualified name following Haskell's scoping rules;Show approximately what Haddock adds to documentation URLs.`Show approximately a haddock link (without haddock root) for an id. This is an illustration and a test of the id info, but under ideal conditions could perhaps serve to link to documentation without going via Hoogle.  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`   `  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`P  !"#$'&%()*+,-./0125436789:;=<>?@ABCDELKGFHIJMNOPQRSTUVWXYZ^]\[_`   None+036:BHM  (Information about a triggered breakpoint The outcome of running code,Execution was paused because of a breakpoint;GHC itself threw an exception when we tried to run the codeThe code threw an exceptionThe code terminated okay,Used only for ghc's PackageImports extension%Used before we convert it to an IdMapWired into the compiler ((), True, etc.) Imported from a different moduleQualifier used for the import IMPORTED AS idImportQual import Data.List "" import qualified Data.List "Data.List." import qualified Data.List as L "L."Defined within this moduleThis is a binding occurrence (f x = .., x -> .., etc.)  ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~g12345Z[\]^  ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgh<  ! "#$%&'(),+*-./0123476589:;<=>?@ABCDEFHGIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None+2346:=HKMIntroduce explicit sharingThis provides the opposite translation to removeExplicitSharing. Note however that this is a partial function -- we never extend the cache, so if a required value is missing from the cache we return Nothing.0Many of the public data types that we export in  IdeSession have a corresponding private XShared version. For instance, we have IdProp and XShared IdProp,  SourceError and XShared SourceError, etc. These XSharedT types are abstract; what's important is only that they can be serialized (support FromJSON and ToJSON). The main difference between the public and the private data types is that the private data types use explicit sharing. This is important for serialization, because there is quite a bit of sharing in the type information that we collect and losing this would be a significant performance hit. (The other difference is that the private data types use specialized types that guarantee strictness.)The MShared (XShared a) ~ a condition on the ExplicitSharingL type class is there for technical reasons only (it convinces GHC that the XShared type family is a bijection).>The inverse of MShared, only for decidability of type checking)The associated type with explicit sharing/-None +036:HMFor debugging only! :)%Initial handshake with the ghc serverIdeally we'd send over the entire IdeStaticInfo but this includes some Cabal fields, and the ghc server does -not- compile against Cabal (although this isn't so important anymore now that we use Cabal-ide-backend)3, None +036:HMaJThis type represents intermediate progress information during compilation.cThe current step number|When these Progress messages are generated from progress updates from ghc, it is entirely possible that we might get step 426, 16c26, 3/26; the steps may not be continuous, might even be out of order, and may not finish at X/X.dThe total number of stepseXThe parsed message. For instance, in the case of progress messages during compilation, f might be F[1 of 2] Compiling M (some/path/to/file.hs, some/other/path/to/file.o)while  progressMsg will just be 'Compiling M'fThe full original message (see  progressMsg) abcdefabcdefabcdefNone +036:HMg GHC version>NOTE: Defined in such a way that the Ord instance makes sense.#ghij     ghijgjih      None+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 server#7Like 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 exceptions' !"#$%' $&' !"#$%None +36:HM kIFor detecting runtime version mismatch between the server and the libraryXWe use a Unix timestamp for this so that these API versions have some semantics (http:/www.epochconverter.com, GMT).(Haskell source files)Haskell .boot files*C source files+C header filesl?Extensions of all source files we keep in our source directory.,/The directory to use for managing source files.-The directory to use for data files that may be accessed by the running program. The running program will have this as its CWD..Cabal "dist" prefix./3Directory where we store compiled C files (objects) k()*+l0,-./Pghijk()*+l0,-./ k()*+l0,-./None +36:HM rgConfiguration parameters for a session. These remain the same throughout the whole session's lifetime.t+The directory to use for all session files.u_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.vTShould the GHC client run in-process? NOTE: This is currently broken. Set to False.w4Whether to generate module type/autocompletion info.xPackage DBs to consultyPackages that don't need the .cabal files provided for license concatenation (e.g., because they are covered by the core license set).zHard-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 } rstuvwxyz{|}~ rstuvwxyz{|}~r stuvwxyz{|}~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.1GMapping from C files to the corresponding .o files and their timestamps2>The collection of source and data files submitted by the user.3A workaround for http:/hackage.haskell.orgtracghcGticket/7473. Logical timestamps (used to force ghc to recompile files)4VThe result computed by the GHC API typing/compilation invocation in the last call to  updateSession invocation.5Current GHC options6#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.76Whether to generate code in addition to type-checking.80Files submitted by the user and not deleted yet.9"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 overrides>7Command line arguments for snippets (expected value of getArgs)?$The GHC server (this is replaced in restartSession)@ GHC versionA$Buffer mode for standard output for runStmtB#Buffer mode for standard error for runStmtC!Are we currently in a breakpoint?DTargets for compilationE6RTS options (for the ghc session, not for executables)F ConfigurationG'(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.HLast compilation and run errorsIModules that got loaded okayJ1Mapping from filepaths to the modules they defineK]Import information. This is (usually) available even for modules with parsing or type errorsLAutocompletion 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).M*Information about identifiers/quasi-quotesN%Type information about subexpressionsO Use sitesP!(Transitive) package dependenciesQ/We access IdProps indirectly through this cacheRRST1U2VWXYZ3456789:;<=>?@ABCDE[\]^_`aFGbcdefHIJKLMNOPQghijklmnopqrstuvwxyz{QRSTU2VWXYZ3456789:;<=>?@ABCDE[\]^_`aFGbcdefHIJKLMNOPQghijklmnopqrstuvwxyz{ RTS1U2VWXYZ3456789:;<=>?@ABCDE[\_^]`aFGbcde fHIJKLMNOPQghijklmnopqrstuvwxyz{None+36:EHM |Start the ghc serverRepeatedly call  until we receive a } result, while collecting all ~ resultsSet the environmentSet command line argumentsSet ghc optionsCompile or typecheckSet breakpointReturns Just. the old value of the break if successful, or Nothing' if the breakpoint could not be found.Run code(NOTE: This is an interruptible operationPrint a variableLoad an object fileUnload an object file-Crash the GHC server (for debugging purposes)Handshake with the server|Initial ghc optionsRelative includes RTS optionsSession setup info GHC serverShould we generate code?TargetsProgress callback GHC server Run commandTranslate run results Nothing indicates force cancellation}RST||None +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.JRun gcc via ghc, with correct parameters. Copied from bits and pieces of Distribution.Simple.GHC.I3#   None +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 _ to translate these V@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 6.&*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 timestamp Unload all current object files Reload 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 parameters.Write 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)0Internal 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.1requiresSessionRestart 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.2listChanges 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 statement3"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.'456,-./7089123*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):;<=>?3465,-./7089123:;<=>?None +36:HM  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~rstuvwxyz{|~}abcdef  gjihZ^]\[UVWXYMNOPQRSTELKGFHIJ>?@ABCD;=<6789:25431-./0()*+,$'&% !"#_`mqpnolk@''()*+,--./0123456789:;<=>?@AABCDEFGHIJKLLMNOPPQRSTUVWXXYZ[\]^__`abcdefghijklmmnopqrstuuvwxyz{|}~ !&&&&&&&&&&&&&&&&&&&       !!"#"$$%&'()*+,-.//0123456789:;<:;=:;>:;>?@ABCDE F F G H I J K L M N O P Q R S T U V I J K R Q P L W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                      764567447   -23567C fgjkl  -./01AABDEFGHIJK>?@LLMNOPPQRXXYZ[\]^__`abcdehimmnopqrsuuvw3 ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}Z~      !"#$%&'()*+,-./00123456789:;;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwxyz{|}~$$%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&&&&&&&&&&&&&&&&c&&&&ide-backend-0.9.0 IdeSessionIdeSession.Strict.StateTIdeSession.Util.PrettyValIdeSession.RPC.StreamIdeSession.Strict.IORefIdeSession.RPC.APIIdeSession.Strict.IntervalMapIdeSession.LicensesIdeSession.Strict.MVarIdeSession.Util.BlockingOpsIdeSession.Strict.ContainerIdeSession.Strict.MaybeIdeSession.Strict.ListIdeSession.Strict.MapIdeSession.UtilIdeSession.Strict.IntMapIdeSession.Strict.TrieIdeSession.Types.PublicIdeSession.Types.PrivateIdeSession.Types.TranslationIdeSession.GHC.RequestsIdeSession.Types.ProgressIdeSession.GHC.ResponsesIdeSession.RPC.ClientIdeSession.GHC.APIIdeSession.ConfigIdeSession.StateIdeSession.GHC.ClientIdeSession.CabalIdeSession.Query"IdeSession.Update.IdeSessionUpdateQuery getDistDirConfig configDynLinkIdeSession.ExeCabalClient&IdeSession.Update.ExecuteSessionUpdateIdeSession.UpdateExternalExceptionexternalStdErrexternalExceptionTargetsTargetsExcludeTargetsInclude BreakInfobreakInfoModule breakInfoSpanbreakInfoResultTypebreakInfoVariableEnv RunResultRunBreakRunForceCancelledRunGhcExceptionRunProgExceptionRunOk RunBufferModeRunBlockBufferingrunBufferBlockSizeRunLineBufferingrunBufferTimeoutRunNoBufferingSpanInfoSpanQQSpanIdImport importModule importPackageimportQualifiedimportImplicitimportAsimportEntitiesImportEntities ImportAll ImportHiding ImportOnly PackageId packageNamepackageVersion packageKeyModuleId moduleName modulePackage ModuleNameSourceErrorKindKindServerDied KindWarning KindError SourceError errorKind errorSpanerrorMsg EitherSpanTextSpan ProperSpan SourceSpan spanFilePath spanFromLinespanFromColumn spanToLine spanToColumnIdScopeWiredInImportedidImportedFrom idImportSpan idImportQualLocalBinderIdPropidNameidSpaceidType idDefinedIn idDefSpan idHomeModuleTypeIdInfoidPropidScope IdNameSpace TcClsNameTvNameDataNameVarNameidInfoQN haddockLinkProgress progressStepprogressNumStepsprogressParsedMsgprogressOrigMsg GhcVersionGHC_7_10GHC_7_8GHC_7_4ideBackendApiVersionsourceExtensionsCabal-ide-backend-1.23.0.0Distribution.Simple.CompilerPackageDBStack UserPackageDBSpecificPackageDBGlobalPackageDB PackageDB SessionConfig configDirconfigExtraPathDirsconfigInProcessconfigGenerateModInfoconfigPackageDBStackconfigLicenseExcconfigLicenseFixed configLogconfigDeleteTempFiles InProcessdefaultSessionConfig 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 setBreakpointprintVarcrashGhcServer StrictState StrictStateT runStateT evalStateT execStateTrunState evalState execState$fMonadTransStrictStateT$fMonadStatesStrictStateT$fFunctorStrictStateT$fMonadStrictStateT$fApplicativeStrictStateT mtl-2.1.3.1Control.Monad.State.Classmodify$fPrettyValText$fPrettyValBool$fPrettyValTrie$fPrettyValMap$fPrettyValIntMap$fPrettyValByteString$fPrettyValMaybepretty-show-1.6.8.2Text.Show.PrettyVal prettyVal PrettyValStream newStream nextInStream StrictIORefnewIORef readIORef writeIORef modifyIORefserverKilledException hPutFlushignoreIOExceptionsopenPipeForWritingopenPipeForReadingRPCPipeNotCreatedIncBSunIncBSResponseRequestRequestShutdownRpcConversationgetput$fShowRPCPipeNotCreated$fExceptionRPCPipeNotCreated $fShowIncBS $fBinaryIncBS$fBinaryResponse$fBinaryRequest$fExceptionExternalException$fShowExternalExceptionStrictIntervalMaptoLazyIntervalMap maxInterval unionInterval dominatorsemptyinsertfromListtoList$fPrettyValStrictIntervalMap$fShowStrictIntervalMapfingertree-0.1.0.2Data.IntervalMap.FingerTreelowhighIntervalLicensebsd3gplv2gplv3lgpl2lgpl3apache20 StrictMVar newEmptyMVarnewMVartakeMVarputMVarreadMVarswapMVar tryTakeMVar tryPutMVar isEmptyMVarwithMVar modifyMVar_ modifyMVar lineNumbermapExceptionIOmapExceptionShowtraceOnExceptiontakeStrictMVar putStrictMVarreadStrictMVarmodifyStrictMVarmodifyStrictMVar_withStrictMVarswapStrictMVarreadChanwait waitCatchwaitAnywaitAnyCatchCancelStrictContainerStrictforceproject StrictTrie toLazyTrie StrictMaybe toLazyMaybe StrictMap toLazyMap StrictList toLazyList StrictIntMap toLazyIntMap$fPrettyValStrictTFCo:R:StrictTriea$fStrictContainerTrie$fAlternativeStrict$fApplicativeStrict$fPrettyValStrict0$fFunctorStrict$fBinaryStrictTFCo:R:StrictMaybea$fStrictContainerMaybe$fPrettyValStrict1$fBinaryStrict0TFCo:R:StrictMapv$fStrictContainerMap$fPrettyValStrict2$fBinaryStrict1TFCo:R:Strict[]a$fStrictContainer[]$fPrettyValStrict3$fBinaryStrict2TFCo:R:StrictIntMapv$fStrictContainerIntMapbase Data.MaybeMaybecontainers-0.5.5.1Data.IntMap.BaseIntMap Data.Map.BaseMapbytestring-trie-0.2.4Data.Trie.InternalTrienothingjustmaybe fromMaybenilcons singletonmapallanyelemreverse++\\union mapWithKeymapKeysunions filterWithKeykeysSetlookupfindWithDefaultalteradjustmember!keyselemsdeleteaccessoraccessorDefaultshowExWithClass accessorNamelookup'writeFileAtomic makeBlockssetupEnvignoreDoesNotExist interruptibleDiffInsertRemoveKeepfflushenvWithPathOverride relInclToOptsparseProgressMessage applyMapDiff swizzleStdout swizzleStderr swizzleHandleredirectStderr captureOutput $fBinaryText$fPrettyValDiff $fBinaryDiff insertWith reverseLookupfiltersubmap fromListWith VariableEnvValue System.IOputStrLnNamehaddockSpaceMarks$fBinaryTargets$fBinaryRunBufferMode$fBinaryIdInfo$fBinaryPackageId$fBinaryModuleId$fBinaryEitherSpan$fBinarySourceSpan$fBinaryIdScope$fBinaryIdProp$fBinarySourceError$fBinaryImport$fBinaryImportEntities$fBinarySourceErrorKind$fBinaryIdNameSpace$fShowSpanInfo $fShowIdInfo$fShowPackageId$fShowModuleId$fShowEitherSpan $fShowIdScope $fShowIdProp$fShowSourceSpan$fToJSONIdNameSpace$fToJSONSourceErrorKind$fToJSONImportEntities$fToJSONImport$fToJSONSourceError$fToJSONIdProp$fToJSONIdScope$fToJSONSourceSpan$fToJSONEitherSpan$fToJSONModuleId$fToJSONPackageId$fToJSONIdInfo$fToJSONSpanInfo$fToJSONBreakInfo$fToJSONRunResult$fPrettyValTargets$fPrettyValBreakInfo$fPrettyValRunResult$fPrettyValRunBufferMode$fPrettyValSpanInfo$fPrettyValImport$fPrettyValImportEntities$fPrettyValPackageId$fPrettyValModuleId$fPrettyValSourceErrorKind$fPrettyValSourceError$fPrettyValEitherSpan$fPrettyValSourceSpan$fPrettyValIdScope$fPrettyValIdProp$fPrettyValIdInfo$fPrettyValIdNameSpace$fToJSONRunBufferModeIdListExplicitSharingCache filePathCache idPropCacheUseSitesExpMap expMapToMapIdMap idMapToMap SpanInSplice IdPropPtr idPropPtr FilePathPtr filePathPtr unionCachemkIdMapmkExpMapspanToIntervalintervalToSpan$fPrettyValExplicitSharingCache$fPrettyValExpMap$fPrettyValIdMap$fPrettyValIdPropPtr$fPrettyValFilePathPtr$fBinaryBreakInfo$fBinaryRunResult$fBinarySpanInfo$fBinaryExplicitSharingCache$fBinaryIdPropPtr$fBinaryFilePathPtrIntroduceSharingExplicitSharingMSharedXSharedintroduceExplicitSharingremoveExplicitSharingshowNormalizeddereferenceFilePathPtr$fIntroduceSharingSourceSpan$fExplicitSharingBreakInfo$fExplicitSharingSpanInfo$fExplicitSharingImport$fExplicitSharingImportEntities$fExplicitSharingSourceError$fExplicitSharingEitherSpan$fExplicitSharingSourceSpan$fExplicitSharingIdScope$fExplicitSharingPackageId$fExplicitSharingModuleId$fExplicitSharingIdInfo$fExplicitSharingIdPropTFCo:R:MSharedBreakInfoTFCo:R:MSharedRunResultTFCo:R:MSharedSpanInfoTFCo:R:MSharedImportTFCo:R:MSharedImportEntitiesTFCo:R:MSharedPackageIdTFCo:R:MSharedModuleIdTFCo:R:MSharedSourceErrorTFCo:R:MSharedEitherSpanTFCo:R:MSharedSourceSpanTFCo:R:MSharedIdScopeTFCo:R:MSharedIdInfoTFCo:R:MSharedIdPropTFCo:R:XSharedBreakInfoTFCo:R:XSharedRunResultTFCo:R:XSharedSpanInfoTFCo:R:XSharedImportTFCo:R:XSharedImportEntitiesTFCo:R:XSharedPackageIdTFCo:R:XSharedModuleIdTFCo:R:XSharedSourceErrorTFCo:R:XSharedEitherSpanTFCo:R:XSharedSourceSpanTFCo:R:XSharedIdScopeTFCo:R:XSharedIdInfoTFCo:R:XSharedIdPropReqCrashGhcInitRequest GhcRunRequestGhcRunInterrupt GhcRunInputRunCmdResumeRunStmt runCmdModulerunCmdFunction runCmdStdout runCmdStderr GhcRequest reqCrashDelay ReqSetGhcOpts reqSetGhcOpts ReqUnload reqUnloadReqLoadreqLoadReqPrint reqPrintVars reqPrintBind reqPrintForce ReqBreakpointreqBreakpointModulereqBreakpointSpanreqBreakpointValue ReqSetArgs reqSetArgs ReqSetEnv reqSetEnvReqRun reqRunCmd ReqCompilereqCompileGenCodereqCompileTargetsghcInitClientApiVersionghcInitGenerateModInfo ghcInitOptsghcInitUserPackageDBghcInitSpecificPackageDBsghcInitSessionDir$fBinaryGhcRunRequest$fBinaryRunCmd$fBinaryGhcRequest$fBinaryGhcInitRequest$fPrettyValRunCmd$fPrettyValGhcRequest$fPrettyValGhcInitRequest$fShowProgress$fBinaryProgress$fPrettyValProgressGhcRunResponse GhcRunDone GhcRunOutpGhcCompileResultghcCompileErrorsghcCompileLoadedghcCompileCacheghcCompileFileMapghcCompileImportsghcCompileAutoghcCompileSpanInfoghcCompilePkgDepsghcCompileExpTypesghcCompileUseSitesGhcCompileResponseGhcCompileDoneGhcCompileProgressGhcInitResponseghcInitVersion$fBinaryGhcVersion$fBinaryGhcRunResponse$fBinaryGhcCompileResult$fBinaryGhcCompileResponse$fBinaryGhcInitResponse$fPrettyValGhcVersion$fPrettyValGhcRunResponse$fPrettyValGhcCompileResult$fPrettyValGhcCompileResponse$fPrettyValGhcInitResponseRpcClientSideState RpcStopped RpcRunning RpcServer rpcRequestW rpcErrorLogrpcProcconnectToRpcServer forkRpcServer rpcResponseRrpcState rpcIdentityrpcrpcConversationshutdown forceShutdown terminateforceTerminate withRpcServergetRpcExitCodemapIOToExternalillscopedConversationException hsExtensionshsBootExtensions cExtensionscHeaderExtensionsideSessionSourceDirideSessionDataDirideSessionDistDirideSessionObjDircabalMacrosLocation 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 forkGhcServer Data.EitherRightLeft rpcSetEnv rpcSetArgs rpcSetGhcOpts rpcCompile rpcBreakpointrpcRunrpcPrintrpcLoad rpcUnloadrpcCrashrpcInit SnippetActionSnippetForceTerminatedSnippetTerminated SnippetOutputsplitPackageDBStackshutdownGhcServerforceShutdownGhcServerghcConversationghcRpcrunComponentCcExeCabalResponse 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(),$fMonadStateIdeIdleStateExecuteSessionUpdateNothingsessionRestartParamsexecInitParams writeMacros verifyConfigshutdownSession'requiresSessionRestart listChangesrunCmd RestartResultServerRestartFailedServerRestartedcheckPackageDbEnvVarexecuteRestartupdateSession' withBreakInfomodifyIdleStatefailedToRestart forcedRestartserverRestartLoop