!R6D      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` abcdefghijklmnopqrstuvwxyz{|}~ None"#$%147MPX_kKghcide2A debouncer can be used to avoid triggering many events (e.g. diagnostics) for the same key (e.g. the same file) within a short timeframe. This is accomplished by delaying each event for a given time. If another event is registered for the same key within that timeframe, only the new event will fire.ghcideCreate a new empty debouncer.ghcidevRegister an event that will fire after the given delay if no other event for the same key gets registered until then.If there is a pending event for the same key, the pending event will be killed. Events are run unmasked so it is up to the user of  to mask if required.None"#$%147MPX_k #$%&'()*+, #$%&'(*)+,None"#$%147MPX_k None"#$%147MPX\_`k!ghcideFind out path to  ghcversion.h fileNone"#$%147MPX_k"-ghcideAn HscEnv with equality. -./0123456 /.31204-56None"#$%147=?MPX_k$ None"#$%147MPX_k-AghcidebType of some span of source code. Most of these fields are unboxed but Haddock doesn't show that.ghcide#Start line of the span, zero-based.ghcide%Start column of the span, zero-based.ghcide,End line of the span (absolute), zero-based.ghcide.End column of the span (absolute), zero-based.ghcide,A pretty-printed representation fo the type.ghcide The actutal  associated with the span, if any. This can be useful for accessing a variety of information about the identifier such as module, locality, definition location, etc. None"#$%147MPX_k3:ghcideCNewtype wrapper around FilePath that always has normalized slashes.=ghcideWe use an empty string as a filepath when we don t have a file. However, haskell-lsp doesn t support that in uriToFilePath and given that it is not a valid filepath it does not make sense to upstream a fix. So we have our own wrapper here that supports empty filepaths. :;<=>?@AB@AB :?;<>=None"#$%147MPX_k=Ighcide/Human readable diagnostics for a specific file.This type packages a pretty printed, human readable error message along with the related source location so that we can display the error on either the console or in the IDE at the right source location.ghcideLabel a document.ghcide.The layout options used for the SDK assistant.ghcide%Render without any syntax annotationsghcide Render a Document as an ANSII colored string.ghcide&Rendering width of the pretty printer. "!IJKLI "!JKLNone"#$%147MPX_gk@ MghcidedPattern synonym to make it a bit more convenient to match on diagnostics in things like damlc test.MMNone"#$%147MPX_kaFPghcideXTransitive module dependencies in topological order. The module itself is not included.Qghcide1Transitive pkg dependencies in unspecified order.ghcideA processed node in the dependency graph. If there was any error during processing the node or any of its dependencies, this is an . Otherwise it is a .Rghcide4An error attached to a node in the dependency graph.SghcideThis module is part of an import cycle. The module name corresponds to the import that enters the cycle starting from this module. The list of filepaths represents the elements in the cycle in unspecified order.Tghcide3This module has an import that couldn t be located.VghcideThis module is the parent of a module that cannot be processed (either it cannot be parsed, is part of a cycle or the parent of another error node).ghcide%Error when trying to locate a module.Wghcide\This does not contain the actual parse error as that is already reported by GetParsedModule.[ghcide)Nodes that cannot be processed correctly.\ghcidebFor a non-error node, this contains the set of module immediate dependencies in the same package.]ghcideBFor a non-error node, this contains the set of immediate pkg deps._ghcideBUnprocessed results that we find by following imports recursively.dghcideFor processing dependency information, we need lots of maps and sets of filepaths. Comparing Strings is really slow, so we work with IntMap/IntSet instead and only convert at the edges andgghcideThe imports for a given module.ighcideeImports of a module in the current package and the file path of that module on disk (if we found it)jghcide8Transitive package dependencies unioned for all imports.ghcideGiven a dependency graph, buildResultGraph detects and propagates errors in that graph as follows: 1. Mark each node that is part of an import cycle as an error node. 2. Mark each node that has a parse error as an error node. 3. Mark each node whose immediate children could not be located as an error. 4. Recursively propagate errors to parents if they are not already error nodes.%NOQPRUSTVWXYZ[\]^_`abcdefghijklmnopqr%YZ[\]^ghij_`abRUSTVWXNOQPdefcklmnopqrNone"#$%147MPX_knghcide;Produce a GHC-style error from a source span and a message.ghcide.Convert a GHC SrcSpan to a DAML compiler RangeghcideExtract a file name from a GHC SrcSpan (use message for unhelpful ones) FIXME This may not be an _absolute_ file name, needs fixing.ghcideFConvert a GHC severity to a DAML compiler Severity. Severities below Warning' level are dropped (returning Nothing).ghcide#Produce a bag of GHC-style errors ( ErrorMessages=) from the given (optional) locations and message strings.ghcide;Produce a GHC-style error from a source span and a message.ghcide:Produces an "unhelpful" source span with the given string.ghcideFcreates a span with zero length in the filename of the argument passedghcidefile path of span None"#$%147MPX_ksAghcideElocate a module in the file system. Where we go from *daml to Haskellghcideelocate a module in either the file system or the package database. Where we go from *daml to Haskellghcide"Don't call this on a found module.None"#$%147MPX_k} ghcide Take a GHC monadic action (e.g. typecheckModule pm for some parsed module 'pm@'i) and produce a "decorated" action that will harvest any warnings encountered executing the action. The phase( argument classifies the context (e.g. Parser,  Typechecker).2The ModSummary function is required because of  ghttps://github.com/ghc/ghc/blob/5f1d949ab9e09b8d95319633854b7959df06eb58/compiler/main/GHC.hs#L623-L640 which basically says that log_action is taken from the ModSummary when GHC feels like it. The given argument lets you refresh a ModSummary log_actionNone"#$%147=?HMPVX_k6 ghcideMContains the typechecked module and the OrigNameCache entry for that module.ghcide1The parse tree for the file using GetFileContentsghcidewResolve the imports in a module to the file path of a module in the same package or the package id of another package.ghcideThe dependency information produced by following the imports recursively. This rule will succeed even if there is an error, e.g., a module could not be located, a module could not be parsed or an import cycle.ghcideThis rule is used to report import cycles. It depends on GetDependencyInformation. We cannot report the cycles directly from GetDependencyInformation since we can only report diagnostics for the current file.ghcideTransitive module and pkg dependencies based on the information produced by GetDependencyInformation. This rule is also responsible for calling ReportImportCycles for each file in the transitive closure.ghcide:The type checked version of this file, requires TypeCheck+ghcide<Information about what spans occur where, requires TypeCheckghcide$Convert to Core, requires TypeCheck*ghcideA GHC session that we reuse.ghcideRead the given HIE file.None"#$%147MPSX_kJghcideNote that this is logging actions _of the program_, not of the user. You shouldn't call warning/error if the user has caused an error, only if our code has gone wrong and is itself erroneous (e.g. we threw an exception).ghcideVerbose debug logging.ghcide9Useful information in case an error has to be understood.ghcideWThese error messages should not occur in a expected usage, and should be investigated.ghcide5Such log messages must never occur in expected usage. None"#$%147MPSX_k ghcideGThe set of options used to locate files belonging to external packages.ghcidelLocate the HIE file for the given module. The PackageConfig can be used to lookup settings like importDirs.ghcideLocate the source file for the given module. The PackageConfig can be used to lookup settings like importDirs. For DAML, we place them in the package DB. For cabal this could point somewhere in ~.cabal packages.ghcideoPreprocessor to run over all parsed source trees, generating a list of warnings along with a new parse tree.ghcide+Setup a GHC session for a given file, e.g. Foo.hs . The  will be called once, then the resulting function will be applied once per file. It is desirable that many files get the same -8, so that more IDE features work. You should not use $ to get that caching, because of  .https://github.com/ndmitchell/shake/issues/725.ghcideHow to locate source and .hie files given a module name.ghcideKFile extensions to search for code, defaults to Haskell sources (including .hs)ghcideENumber of threads to use. Use 0 for number of threads on the machine.ghcideSet to , to create a directory of profiling reports.ghcide2Whether to report progress during long operations.ghcidethe ```language to useghcide#whether to use new colon convention None"#$%,147EHMPVX_kgghcideWe store the modification time as a ByteString since we need a ByteString anyway for Shake and we do not care about how times are represented.ghcide5This is what we use when we get Nothing from a rule.ghcideThis is used both for  as well as .ghcideInvariant: the vK must be in normal form (fully evaluated). Otherwise we keep repeatedly ing values taken from the Shake database Note (MK) I am not sure why we need the ShakeValue here, maybe we can just remove it?ghcideWhen we depend on something that reported an error, and we fail as a direct result, throw BadDependency which short-circuits the rest of the actionghcideVA Shake database plus persistent store. Can be thought of as storing mappings from  (FilePath, k) to  RuleResult k.ghcideThe result of an IDE operation. Warnings and errors are in the Diagnostic, and a value is in the Maybe. For operations that throw an error you expect a non-empty list of diagnostics, at least one of which is an error, and a Nothing. For operations that succeed you expect perhaps some warnings and a Just. For operations that depend on other failing operations you may get empty diagnostics and a Nothing, to indicate this phase throws no fresh errors but still failed.A rule on a file should only return diagnostics for that given file. It should not propagate diagnostic errors through multiple phases.ghcideKey typeghcideThe state of the all values.ghcidewThis represents the set of diagnostics that we have published. Due to debouncing not every change might get published.ghcideMap from a text document version to a PositionMapping that describes how to map positions in a version of that document to positions in the latest versionghcide2Convert a Value to a Maybe. This will only return + for up2date results not for stale values.ghcidefReturn the most recent, potentially stale, value and a PositionMapping for the version of that value.ghcide^We return Nothing if the rule has not run and Just Failed if it has failed to produce a value.ghcideSeq the result stored in the Shake value. This only evaluates the value to WHNF not NF. We take care of the latter elsewhere and doing it twice is expensive. ghcideOpen a , should be shut using .ghcidegSpawn immediately. If you are already inside a call to shakeRun that will be aborted with an exception.ghcide[FIXME: This function is temporary! Only required because the files of interest doesn't workghcideFClear the results for all files that do not match the given predicate.ghcide6Return up2date results. Stale results will be ignored.ghcide5Return the last computed result which might be stale.ghcideySets the diagnostics for a file and compilation step if you want to clear the diagnostics call this with an empty listghcide$Get the modification time of a file. ghcidediagnostic handlerghcidecurrent resultsghcideGthe time that the file these diagnostics originate from was last edited$      !$      ! None"#$%147=?HMPVX_k?ghcideBSet the files-of-interest which will be built and kept-up-to-date.=>?@=>?@ None"#$%147HMPVX_k&Gghcidehaskell-lsp manages the VFS internally and automatically so we cannot use the builtin VFS without spawning up an LSP server. To be able to test things like M) we abstract over the VFS implementation.ghcide"get the contents of a virtual fileghcide~set a specific file to a value. If Nothing then we are ignoring these signals anyway so can just say something was modifiedMghcideMNotify the compiler service that a particular file has been modified. Use ` to say the file is no longer in the virtual file system but should be sourced from disk, or  to give its new value.NghcideNote that some buffer somewhere has been modified, but don't say what. Only valid if the virtual file system was initialised by LSP, as that independently tracks which files are modified.ghcideDoes the file exist.ghcidefGet the contents of a file, either dirty (if the buffer is modified) or Nothing to mean use from disk.GHIJKLMNKJMNLGHI None"#$%147=?HMPVX_k Zghcide Initialise the Compiler Service.\ghcideShutdown the Compiler Service.^ghcide^ is similar to ]7 but it will wait for all rules (so in particular the ofInterestRule) to finish running. This is mainly useful in tests, where you want to wait for all rules to fire so you can check diagnostics. !Z[\]^_ _Z\]^[!None"#$%147MPSX_dk"abcdefcdefabNone"#$%147MPSX_dkNone"#$%147MPSX_k ghcide.Given a string buffer, return a pre-processed  ParsedModule.ghcide;Given a package identifier, what packages does it depend onghcideGTypecheck a single module using the supplied dependencies and packages.ghcide*Compile a single type-checked module to a  value, or provide errors.ghcideMSetup the environment that GHC needs according to our best understanding (!)ghcideLoad a module, quickly. Input doesn't need to be desugared. A module must be loaded before dependent modules can be typechecked. This variant of loadModuleHome will *never* cause recompilation, it just modifies the session.ghcideuGhcMonad function to chase imports of a module given as a StringBuffer. Returns given module's name and its imports.ghcide-Produce a module summary from a StringBuffer.ghcideERun (unlit) literate haskell preprocessor on a file, or buffer if setghcideRun CPP on a fileghcideqGiven a buffer, flags, file path and module summary, produce a parsed module (or errors) and any parse warnings.ghcideDThis reads the pragma information directly from the provided buffer.ghcideRun something in a Ghc monad and catch the errors (SourceErrors and compiler-internal exceptions like Panic or InstallationError).ghcide#the filename (for source locations)ghcide6Haskell module source text (full Unicode is supported) None"#$%147MPSX_kIghcide@Get source span info, used for e.g. AtPoint and Goto Definition.ghcide#Get ALL source spans in the module.ghcide:Variant of GHC's ieNames that produces LIdP instead of IdPghcide#Get the name and type of a binding.ghcide'Get the name and type of an expression.ghcide#Get the name and type of a pattern.ghcide#Get ALL source spans in the source.ghcidePretty print the types into a .ghcideimportsNone"#$%147MPX_k_ghcide$Shows this part of the documentationghcide$The name you want documentation for.ghcide3All of the possible modules it could be defined in.None"#$%147MPX_kghcide6Locate the definition of the name at a given position.ghcide*Synopsis for the name at a given position.None"#$%147=?HMPVX_dk* jghcideThis is useful for rules to convert rules that can only produce errors or a result into the more general IdeResult type that supports producing warnings while also producing a result.kghcideeuseE is useful to implement functions that aren t rules but need shortcircuiting e.g. getDefinition.oghcideAGenerate the GHC Core for the supplied file and its dependencies.pghcideZGet all transitive file dependencies of a given module. Does not include the file itself.qghcide/Try to get hover text for the name under point.rghcideGoto Definition.sghcide"Parse the contents of a daml file.tghcideSWrite interface files and hie files to the location specified by the given options.ghcideaGiven a target file path, construct the raw dependency results by following imports recursively.xghcide)A rule that wires per-file rules togetherNOQP]jklmnopqrstuvwxyNOQPuvw]klmjnxoqrpsytNone"#$%147MPX_k-ghcideDisplay information on hover.None"#$%147MPX_k.zghcide#Go to the definition of a variable. None"#$%147MPX_dk0)ghcideGenerate code actions.ghcideAll the GHC extensionsNone"#$%147EMPX_k68ghcideA message that we need to deal with - the pieces are split up with existentials to gain additional type safety and defer precise processing until later (allows us to keep at a higher level of abstraction slightly longer) ghcideeThings that get sent to us, but we don't deal with. Set them to avoid a warning in VS Code output. !"#$%&$%'$%($%)$%*$%+$%,$%,$%-$%.$%/$%0$%1$23$24$25$25$26$27$28$28$29$2:$2;$2;$<=$<>$<?$<@$<A$<A$<B$CD$CDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrstuvwwxxyz{|}}~                                           ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 [ \ ] ^ _ ` a b c d e f g h ijjkklmnopqrstuvwxyz{|}~                              #ghcide-0.0.2-Ct0TzW6qltrFBHErWtUhit!Development.IDE.Types.DiagnosticsDevelopment.IDE.Types.Location$Development.IDE.Core.PositionMappingDevelopment.IDE.GHC.UtilDevelopment.IDE.LSP.Protocol,Development.IDE.Import.DependencyInformationDevelopment.IDE.Core.RuleTypesDevelopment.IDE.Types.LoggerDevelopment.IDE.Types.OptionsDevelopment.IDE.Core.ShakeDevelopment.IDE.Core.OfInterestDevelopment.IDE.Core.FileStoreDevelopment.IDE.Core.ServiceDevelopment.IDE.LSP.ServerDevelopment.IDE.Core.Rules"Development.IDE.LSP.LanguageServerDevelopment.IDE.Core.DebouncerDevelopment.IDE.GHC.CompatDevelopment.IDE.GHC.CPPDevelopment.IDE.GHC.OrphansDevelopment.IDE.Spans.TypeDevelopment.IDE.GHC.Error"Development.IDE.Import.FindImportsDevelopment.IDE.GHC.Warnings!Development.IDE.LSP.NotificationsDevelopment.IDE.Core.CompileDevelopment.IDE.Spans.Calculate#Development.IDE.Spans.DocumentationDevelopment.IDE.Spans.AtPointDevelopment.IDE.LSP.HoverDevelopment.IDE.LSP.DefinitionDevelopment.IDE.LSP.CodeAction+haskell-lsp-0.16.0.0-2neeSVYjGlk1CQaGy7dq6i Language.Haskell.LSP.DiagnosticsDiagnosticStore1haskell-lsp-types-0.16.0.0-2N7GcVxXe0eLgKUQjIb2pI%Language.Haskell.LSP.Types.Diagnostic#$sel:_relatedInformation:Diagnostic$sel:_message:Diagnostic$sel:_source:Diagnostic$sel:_code:Diagnostic$sel:_severity:Diagnostic$sel:_range:Diagnostic DiagnosticDsHintDsInfo DsWarningDsErrorDiagnosticSeverity#Language.Haskell.LSP.Types.Location_range_uriLocation_end_startRange _character_linePositionLanguage.Haskell.LSP.Types.Uri filePathToUrifromNormalizedUritoNormalizedUrigetUriUri NormalizedUriLanguage.Haskell.LSP.Types.ListListPositionMappingtoCurrentPositionfromCurrentPositiontoCurrentRangefromCurrentRange idMapping applyChange toCurrent fromCurrentHscEnvEqmodifyDynFlagslookupPackageConfigtextToStringBuffer prettyPrint runGhcEnv fakeDynFlagsmoduleImportPathshscEnv newHscEnvEq$fNFDataHscEnvEq $fEqHscEnvEq$fShowHscEnvEqNormalizedFilePathtoNormalizedFilePathfromNormalizedFilePathuriToFilePath'filePathToUri'fromUri noFilePathnoRange showPosition$fIsStringNormalizedFilePath$fEqNormalizedFilePath$fOrdNormalizedFilePath$fShowNormalizedFilePath$fHashableNormalizedFilePath$fNFDataNormalizedFilePathFileDiagnostic ideErrorTextshowDiagnosticsshowDiagnosticsColoredEventFileDiagnosticsTransitiveDependenciestransitiveModuleDepstransitivePkgDeps NodeError PartOfCycleFailedToLocateImport ParseErrorParentOfErrorNodeModuleParseErrorDependencyInformation depErrorNodes depModuleDeps depPkgDeps depPathIdMapRawDependencyInformation rawImports rawPathIdMap PathIdMap FilePathId getFilePathId ModuleImports moduleImportspackageImportsemptyPathIdMap getPathId insertImportpathToIdidToPathreachableModulesprocessDependencyInformationtransitiveDeps$fNFDataPathIdMap$fNFDataModuleParseError$fNFDataLocateError$fNFDataNodeError$fNFDataDependencyInformation$fSemigroupNodeResult$fNFDataTransitiveDependencies$fShowFilePathId$fNFDataFilePathId$fEqFilePathId$fOrdFilePathId$fShowPathIdMap$fGenericPathIdMap$fShowModuleParseError$fGenericModuleParseError$fEqLocateError$fShowLocateError$fGenericLocateError$fShowNodeError$fGenericNodeError$fShowDependencyInformation$fGenericDependencyInformation$fShowNodeResult$fEqTransitiveDependencies$fShowTransitiveDependencies$fGenericTransitiveDependencies GetHieFile GhcSession GenerateCore GetSpanInfo TypeCheckGetDependenciesReportImportCyclesGetDependencyInformationGetLocatedImportsGetParsedModuleTcModuleResult tmrModule tmrModInfo$fNFDataTcModuleResult$fShowTcModuleResult$fNFDataGetParsedModule$fHashableGetParsedModule$fNFDataGetLocatedImports$fHashableGetLocatedImports $fNFDataGetDependencyInformation"$fHashableGetDependencyInformation$fNFDataReportImportCycles$fHashableReportImportCycles$fNFDataGetDependencies$fHashableGetDependencies$fNFDataTypeCheck$fHashableTypeCheck$fNFDataGetSpanInfo$fHashableGetSpanInfo$fNFDataGenerateCore$fHashableGenerateCore$fNFDataGhcSession$fHashableGhcSession$fNFDataGetHieFile$fHashableGetHieFile$fEqGetParsedModule$fShowGetParsedModule$fGenericGetParsedModule$fEqGetLocatedImports$fShowGetLocatedImports$fGenericGetLocatedImports$fEqGetDependencyInformation$fShowGetDependencyInformation!$fGenericGetDependencyInformation$fEqReportImportCycles$fShowReportImportCycles$fGenericReportImportCycles$fEqGetDependencies$fShowGetDependencies$fGenericGetDependencies $fEqTypeCheck$fShowTypeCheck$fGenericTypeCheck$fEqGetSpanInfo$fShowGetSpanInfo$fGenericGetSpanInfo$fEqGenerateCore$fShowGenerateCore$fGenericGenerateCore$fEqGhcSession$fShowGhcSession$fGenericGhcSession$fEqGetHieFile$fShowGetHieFile$fGenericGetHieFileLogger logPriorityPriorityDebugInfoWarningErrorlogError logWarninglogInfologDebug noLogging $fEqPriority$fShowPriority $fOrdPriority$fEnumPriority$fBoundedPriorityIdePkgLocationOptionsoptLocateHieFileoptLocateSrcFileIdeReportProgress IdeOptionsoptPreprocessor optGhcSessionoptPkgLocationOpts optExtensions optThreadsoptShakeProfilingoptReportProgressoptLanguageSyntaxoptNewColonConventionclientSupportsProgressdefaultIdeOptions FileVersion VFSVersionModificationTimeGetModificationTimeIdeStateIdeRule IdeResult IsIdeGlobal addIdeGlobalgetIdeGlobalActiongetIdeGlobalState shakeOpen shakeProfile shakeShutshakeRungetDiagnosticsunsafeClearDiagnosticsgarbageCollectdefineuse useWithStale useNoFileuse_ useNoFile_uses_uses usesWithStaledefineEarlyCutoff setPriority sendEvent ideLogger actionLoggerupdatePositionMapping $fHashableKey$fEqKey $fShowKey $fNFDataValue$fExceptionBadDependency$fShowQ $fBinaryQ$fNFDataShakeValue $fNFDataA$fNFDataGetModificationTime$fHashableGetModificationTime$fNFDataFileVersion$fFunctorValue$fGenericValue $fShowValue$fShowBadDependency$fEqQ $fHashableQ $fNFDataQ$fGenericShakeValue$fShowShakeValue$fShowA$fEqGetModificationTime$fShowGetModificationTime$fGenericGetModificationTime$fShowFileVersion$fGenericFileVersionofInterestRulesgetFilesOfInterestsetFilesOfInterestmodifyFilesOfInterest$fIsIdeGlobalOfInterestVar$fNFDataGetFilesOfInterest$fHashableGetFilesOfInterest$fEqGetFilesOfInterest$fShowGetFilesOfInterest$fGenericGetFilesOfInterest VFSHandle makeVFSHandlemakeLSPVFSHandlegetFileContents getFileExistsfileStoreRulessetBufferModifiedsetSomethingModified$fIsIdeGlobalVFSHandle$fNFDataGetFileExists$fHashableGetFileExists$fNFDataGetFileContents$fHashableGetFileContents$fEqGetFileExists$fShowGetFileExists$fGenericGetFileExists$fEqGetFileContents$fShowGetFileContents$fGenericGetFileContents initialise writeProfileshutdown runAction runActionSync getIdeOptions$fIsIdeGlobalGlobalIdeOptionsPartialHandlers WithMessage$sel:withResponse:WithMessage!$sel:withNotification:WithMessage$fMonoidPartialHandlers$fSemigroupPartialHandlers$fDefaultPartialHandlers toIdeResultuseE useNoFileEusesE defineNoFile getGhcCoregetDependencies getAtPoint getDefinitiongetParsedModulewriteIfacesAndHiepriorityTypeCheckpriorityGenerateCorepriorityFilesOfInterestmainRulefileFromParsedModule$fNFDataGhcSessionIO$fHashableGhcSessionIO$fNFDataGhcSessionFun$fShowGhcSessionFun$fEqGhcSessionIO$fShowGhcSessionIO$fGenericGhcSessionIOrunLanguageServer Debouncer newDebouncer registerEventghcDynFlagsincludePathsQuoteincludePathsGlobal HieFileResulthie_file_resultHieFile hie_module hie_exportshPutStringBuffer mkHieFile writeHieFile readHieFileaddIncludePathsQuoteghcEnumerateExtensionsgetGhcVersionPathNamedoCppSpanInfospaninfoStartLinespaninfoStartColspaninfoEndLinespaninfoEndCol spaninfoTypespaninfoSourceName SpanSourceNamedSpanSNoSourcegetNameMslabel_ cliLayout srenderPlainsrenderColored NodeResult ErrorNode SuccessNode LocateErrorbuildResultGraphdiagFromErrMsgsrcSpanToRangesrcSpanToFilename toDSeveritydiagFromStringsdiagFromStringnoSpanzeroSpandiagFromErrMsgssrcSpanToLocationrealSpandiagFromGhcExceptionlocateModuleFile locateModule notFoundErrImport FileImport PackageImport withWarningsD:R:RuleResultGetParsedModuleD:R:RuleResultGetLocatedImports&D:R:RuleResultGetDependencyInformation D:R:RuleResultReportImportCyclesD:R:RuleResultGetDependenciesD:R:RuleResultTypeCheckD:R:RuleResultGetSpanInfoD:R:RuleResultGenerateCoreD:R:RuleResultGhcSessionD:R:RuleResultGetHieFileghc-prim GHC.TypesIO#shake-0.18.3-KFZKOUA6bpR8zCoMZGPCPS&Development.Shake.Internal.Core.Action newCacheIObase GHC.MaybeJust ShakeNoCutoff ShakeResultFailed SucceededAdeepseq-1.4.4.0Control.DeepSeqrnf BadDependencyKeyValuespublishedDiagnosticspositionMapping currentValue lastValue getValuesseqValuesetStageDiagnostics!D:R:RuleResultGetModificationTimeupdateFileDiagnosticsgetVirtualFilesetVirtualFileContentsNothingD:R:RuleResultGetFileExistsD:R:RuleResultGetFileContentssetHandlersNotifications parseModulecomputePackageDepstypecheckModule compileModuleGHC CoreModulesetupEnvloadModuleHomegetImportsParsedgetModSummaryFromBufferrunLhsrunCppparseFileContentsparsePragmasIntoDynFlagscatchSrcErrorsaddRelativeImportgetSrcSpanInfos getSpanInfoieLNamesgetTypeLHsBindgetTypeLHsExpr getTypeLPatlistifyAllSpans toSpanInfo docHeadersgetDocumentationgotoDefinitionatPointrawDependencyInformationonHoversetHandlersHoversetHandlersDefinition codeAction ghcExtensionssetHandlersCodeActionMessagesetHandlersIgnore