!@*       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./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 [ \ ] ^ _ ` 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 { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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 i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                              ! " # $ % & ' ( ) * + , - . / 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 i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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 i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 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 i j k l m n o p q r s t u v w x y z { | } ~                                                                                           8None"#$%147>MPX_k  None"#$%147>MPX_k? ghcide2A 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.We abstract over the debouncer used so we an use a proper debouncer in the IDE but disable debouncing in the DAML CLI compiler. ghcide9Debouncer used in the IDE that delays events as expected. 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. ghcideFDebouncer used in the DAML CLI compiler that emits events immediately.        None"#$%147>MPX_kʯ ghcideCEither an exact position, or the range of text that was substituted ghcide:Fields need to be non-strict otherwise bind is exponential ghcideCompose two position mappings. Composes in the same way as function composition (ie the second argument is applyed to the position first). (ghcide6Convert a set of changes into a delta from k to k + 1 )ghcide>Add a new delta onto a Mapping k n to make a Mapping (k - 1) n            ! " # $ % & ' ( ) * + ,        ! " # $     ) ( % & * ' + , None"#$%124567=>?MPX_kj$ 3ghcideScope of a type variable.%This warrants a data type apart from  66 because of complexities introduced by features like -XScopedTypeVariables and -XInstanceSigs. For example, consider: "foo, bar, baz :: forall a. a -> a Here a' is in scope in all the definitions of foo, bar, and baz, so we need a list of scopes to keep track of this. Furthermore, this list cannot be computed until we resolve the binding sites of foo, bar, and baz.Consequently, a starts with an  5 [foo, bar, baz] Nothing# which later gets resolved into a  4. 5ghcide4Unresolved scopes should never show up in the final .hie file ;ghcidetype or data family <ghcide type synonym =ghcidedata declaration >ghcideconstructor declaration ?ghcidepattern synonym @ghcideclass declaration Aghcideinstance declaration JghcideTypes of imports and exports Oghcide0Different contexts under which identifiers exist Pghcideregular variable Rghcide import/export Tghcide Value binding UghcidePattern binding{This case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with -XViewPatterns) 'do (b, a, (a -> True)) <- bar foo a The identifier a% has two scopes: in the view pattern  (a -> True) and in the rest of the do -block in foo a. Wghcide Declaration Xghcide Type variable Yghcide Record field Zghcide,Information associated with every identifierWe need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on) `ghcide'The information stored in one AST node.The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]). bghcide=(name of the AST node constructor, name of the AST node Type) cghcide'The Haskell types of this node, if any. dghcide%All the identifiers and their details jghcide*Mapping from filepaths (represented using  ) to the corresponding AST mghcidenA list of type arguments along with their respective visibilities (ie. is this an argument that would return   for isVisibleArgFlag?). oghcide(Roughly isomorphic to the original core Type. rghcideA flattened version of Type.9See Note [Efficient serialization of redundant type info] xghcidetype with constraint: t1 => t2 (see  ) }ghcideNGHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:a simplified AST3nodes are annotated with source positions and types0identifiers are annotated with scope information+the raw bytes of the initial Haskell source#Besides saving compilation cycles, .hie; files also offer a more stable interface than the GHC API. ghcide Initial Haskell source file path ghcideThe module this HIE file is for ghcideTypes referenced in the  .9See Note [Efficient serialization of redundant type info] ghcide$Type-annotated abstract syntax trees ghcide"The names that this module exports ghcide'Raw bytes of the initial Haskell source ghcideCurrent version of .hie files 5ghcide3names of the definitions over which the scope spansghcide|the location of the instance/class declaration for the case where the type variable is declared in a method type signature Tghcide,whether or not the binding is in an instanceghcide#scope over which the value is boundghcidespan of entire binding Ughcidescope in the pattern9 (the variable bound can be used further in the pattern)ghcide%rest of the scope outside the patternghcidespan of entire binding Wghcidetype of declarationghcidespan of entire bindingT 3 5 4 6 9 8 7 : A @ ? > = < ; B D C E I H G F J N M L K O Y X W V U T S R Q P Z [ ] \ ^ _ ` a d c b e f i h g j k l m n o p q r { z y x w v u t s | } ~  !None"#$%147>MPX_k ghcide 's get converted into  's before being written into .hie files. See   and  6 for logic on how to convert between these two types. ghcide1The header for HIE files - Capital ASCII letters HIE. ghcideWrite a  } to the given  ., with a proper header and symbol tables for  s and  s ghcideRead a  } from a  . Can use an existing  H. Allows you to specify which versions of hieFile to attempt to read.  * case returns the failing header versions. ghcideRead a  } from a  . Can use an existing  . "None"#$%147=>?MPX_k(s ghcide>One must contain the other. Leaf nodes cannot contain anything ghcide/Insert an AST in a sorted list of disjoint Asts ghcideMerge two nodes together.,Precondition and postcondition: elements in  c are ordered. ghcideCMerge two sorted, disjoint lists of ASTs, combining when necessary.1In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).>However, since Haskell does have position-altering pragmas it isT possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans: ~module Baz where # line 3 "Baz.hs" foozball :: Int foozball = 0 # line 3 "Baz.hs" bar, quuuuuux :: Int bar = 1 quuuuuux = 2 8In these cases, we just do our best to produce sensible  e~'s. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...). ghcide*combines and sorts ASTs using a merge sort ghcidehelps fill in  b (with  )ghcide)return an empty list if this is unhelpful ghcidehelps fill in  b (with  )ghcide)return an empty list if this is unhelpfulghcidetype to associate with the node- #None"#$%147>MPX_k+ ghcideiLook for any identifiers which occur outside of their supposed scopes. Returns a list of error messages. $None"#$%.1247=>?HMPVX_kKE ghcideUsed to collect type info ghcideThe main worker class ghcidekdefined so that HsImplicitBndrs and HsWildCardBndrs can know what their implicit bindings are scoping over ghcidezFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScoped ghcide Pattern scope ghcideScope spans over everything to the right of a, (mostly) not including a itself (Includes a in a few special cases like recursive do bindings) or let/where bindings ghcidecontext for type signaturesghcide#context for pattern synonym fields.ghcidecontext for imports/exportsghcidecontext for imports/exportsghcidecontext for record fieldsghcideMarks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in HsExprs, say, because HsType GhcTc should never occur. ghcide Construct an  }% from the outputs of the typechecker.ghcide2Each element scopes over the elements to the rightghcide specialised to   thingsghcide specialised to   thingsghcideDummy instances - never called ghcide!This instance tries to construct  e nodes which include the type of the expression. It is not yet possible to do this efficiently for all expression forms, so we skip filling in the type for those inputs., for example, doesn't have any type information available directly on the node. Our next recourse would be to desugar it into a CoreExpr then query the type of that. Yet both the desugaring call and the type query both involve recursive calls to the function and argument! This is particularly problematic when you realize that the HIE traversal will eventually visit those nodes too and ask for their types again.tSince the above is quite costly, we just skip cases where computing the expression's type is going to be expensive. See #16233 ghcideuse site of the patternghcide*pattern to the right of a, not including a None"#$%,147=>?MPX_gkN  ghcideAdd the -boota suffix to all output file paths associated with the module, not including the input file itself   !"#$%&'()*+,-./0123456789:;<=>?A@EDCBLKJIHGSRQPONMWVUTXYZ`_^]\[abcdeihgfjklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    )('&*10/.-,+7:98;<=>?@ABCDE_^]\[ZYXWVUTSRQPONMLKJIHGFedcba`hgfkijonmlxwvuzy~}|{      *)('&%$#"!+-,10/.;:98765432<=CBA@?>FDEGVUTSRQPONMLKJIHWXYZ[\]`_^adcbefnmlkjihgoyxwvutsrqpz~}|{      !"#$%&'()*+,-./0123456789:;<=>?@DCBAEGFIHJKLMNhgfedcba`_^]\[ZYXWVUTSRQPOlkjitsrqponmz{yxwvu~|}     10/.-,+*)('&%$#"! 3265487=<;:9@?>AHFGEDCBLKJIMRQPONVUTS\[ZYXW`^_]gfedcbajihwvutsrqponmlkzyx{|}~  tsrqp%$#"!65432     ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      i h g f e d m k l j s r q p o n t u v w x y } | { z ~    c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & % $ # " !                            ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  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 i j k l m n o p q r s t u v w x y z { | } ~  F } ~   } y   !"#$%&'()*+,-./0123456789:;<=>?A@EDCBLKJIHGSRQPONMWVUTXYZ`_^]\[abcdeihgfjklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    )('&*10/.-,+7:98;<=>?@ABCDE_^]\[ZYXWVUTSRQPONMLKJIHGFedcba`hgfkijonmlxwvuzy~}|{      *)('&%$#"!+-,10/.;:98765432<=CBA@?>FDEGVUTSRQPONMLKJIHWXYZ[\]`_^adcbefnmlkjihgoyxwvutsrqpz~}|{      !"#$%&'()*+,-./0123456789:;<=>?@DCBAEGFIHJKLMNhgfedcba`_^]\[ZYXWVUTSRQPOlkjitsrqponmz{yxwvu~|}     10/.-,+*)('&%$#"! 3265487=<;:9@?>AHFGEDCBLKJIMRQPONVUTS\[ZYXW`^_]gfedcbajihwvutsrqponmlkzyx{|}~  tsrqp%$#"!65432     ! "#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      i h g f e d m k l j s r q p o n t u v w x | { z ~    c b a ` _ ^ ] \ [ Z Y X W V U T S R Q P O N M L K J I H G F E D C B A @ ? > = < ; : 9 8 7 6 5 4 3 2 1 0 / . - , + * ) ( ' & % $ # " !                            ~}|{zyxwvutsrqponmlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"!  F } ~  | r { z y x w v u t s q o p m n j k l e f i h g ` a d c b _ ^ Z [ ] \ O Y X W V U T S R Q P J N M L K E I H G F B D C : A @ ? > = < ; 6 9 8 7 3 5 4 %None"#$%147>MPX\_`k( ghcideFind out path to  ghcversion.h file  &None"#$%147>MPX_kghcide%A monad transformer implementing the  effect'None"#$%147>MPX_kjghcide"Add position indexing to a String. indexedByPositionStartingFrom (0,0) "hey\n ho" "a [ ((0,0),'h') , ((0,1),'e') , ((0,2),'y') , ((0,3),'\n') , ((1,0),' ') , ((1,1),'h') , ((1,2),'o') ]ghcide"Add position indexing to a String. @indexedByPosition = indexedByPositionStartingFrom (Position 0 0)ghcideReturns a tuple (before, contents, after) if the range is present. The range is present only if both its start and end positions are presentghcide?Strips out all the positions included in the range. Returns @ if the start or end of the range are not included in the input.ghcideReturns the smallest possible set of disjoint ranges that is equivalent to the input. Assumes input ranges are sorted on the start positions.ghcide_Returns a sorted list of ranges with extended selections including preceding or trailing commas \ a, |b|, c ===> a|, b|, c a, b, |c| ===> a, b|, c| a, |b|, |c| ===> a|, b||, c| (None"#$%147>MPX_kM None"#$%147>MPX_k ghcideThe haddock html page ghcide The hyperlinked source html page ghcide#Get ALL source spans in the source.  )None"#$%147>MPX_k ghcideEnd result of the completionsghcide6All module names in scope. Prelude is a single moduleghcideAll Possible completion itemsghcide:Completion items associated to to a specific module name. ghcide!All modules that may be imported.!ghcideSnippet for the completion"ghcide&From where this item is imported from.#ghcideAvailable type information.$ghcideLabel to display to the user.%ghcide?Did the completion happen in the context of an infix notation.&ghcideAvailable documentation.' ()*+,$!&-"#%./01None"#$%147>MPX_k 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. ghcide Parser for the GHC output format                  None"#$%147>MPX_k ghcide/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. ghcideODefines whether a particular diagnostic should be reported back to the user.One important use case is "missing signature" code lenses, for which we need to enable the corresponding warning during type checking. However, we do not want to show the warning unless the programmer asks for it (#261). ghcideReport back to the user ghcideHide from user 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.2ghcideLabel a document.3ghcide.The layout options used for the SDK assistant.4ghcide%Render without any syntax annotations5ghcide Render a Document as an ANSII colored string.3ghcide&Rendering width of the pretty printer.             None"#$%147>MPX_gk_ ghcidedPattern synonym to make it a bit more convenient to match on diagnostics in things like damlc test.  None"#$%147>MPX_kE ghcideAn ] with equality. Two values are considered equal if they are created with the same call to  . ghcidejIn memory components for this HscEnv This is only used at the moment for the import dirs in the DynFlags ghcidegIf Just, import dirs originally configured in this env If Nothing, the env import dirs are unaltered ghcide2Used to modify dyn flags in preference to calling 9D, since that function also reloads packages (which is very slow). ghcideGiven a   try and find the associated 6 in the environment. ghcideConvert from the text package to the GHC 7U. Currently implemented somewhat inefficiently (if it ever comes up in a profile). ghcide7Pretty print a GHC value using 'unsafeGlobalDynFlags '. ghcidePretty print a  wrapping operators in parens ghcidePretty print a   wrapping operators in parens ghcideRun a  monad value using an existing g. Sets up and tears down all the required pieces, but designed to be more efficient than a standard =. ghcideRun a  monad value using an existing g. Sets up and tears down all the required pieces, but designed to be more efficient than a standard =. ghcideGiven a module location, and its parse tree, figure out what is the include directory implied by it. For example, given the file /usr/Test/Foo/Bar.hs with the module name Foo.Bar the directory  /usr/Test7 should be on the include path to find sibling modules. ghcideWrap an  into an  . ghcideWrap an  into an  . ghcide Unwrap the B with the original import paths. Used only for locating imports ghcideQRead a UTF8 file, with lenient decoding, so it will never raise a decoding error. ghcideConvert from a 8 to a `. !ghcide Convert a 9 to a :M by copying the byte across. Will produce an 8 byte unreadable ByteString. "ghcide Take the 9 of a 7. #ghcideA slightly modified version of  hDuplicateTo7 from GHC. Importantly, it avoids the bug listed in  6https://gitlab.haskell.org/ghc/ghc/merge_requests/2318.;ghcide;This is copied unmodified from GHC since it is not exposed.<ghcide_This is copied unmodified from GHC since it is not exposed. Note the beautiful inline comment!=ghcide;This is copied unmodified from GHC since it is not exposed.                   ! " #                 ! "  #  None"#$%1479;>MPX_k ) * , + - . / 0 1 2 ) * , + - . / 0 1 2*None"#$%147>MPX_k">ghcidebType 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.Aghcide,End line of the span (absolute), zero-based.Bghcide.End column of the span (absolute), zero-based.Cghcide-A pretty-printed representation for the type.Dghcide 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.EghcideDocumentation for the elementFGHIJ>K?@ABCDELMNOP+None"#$%147>HMPVX_kE ) * , + - .QR,None"#$%147=>?MPX_k4 None"#$%147>MPX_k$ <ghcide;Produce a GHC-style error from a source span and a message. >ghcide.Convert a GHC SrcSpan to a DAML compiler Range @ghcideExtract a file name from a GHC SrcSpan (use message for unhelpful ones) FIXME This may not be an _absolute_ file name, needs fixing. CghcideFConvert a GHC severity to a DAML compiler Severity. Severities below Warning' level are dropped (returning Nothing). Dghcide#Produce a bag of GHC-style errors ( ErrorMessages=) from the given (optional) locations and message strings. Eghcide;Produce a GHC-style error from a source span and a message. Fghcide:Produces an "unhelpful" source span with the given string. GghcideFcreates a span with zero length in the filename of the argument passed IghcideRun something in a Ghc monad and catch the errors (SourceErrors and compiler-internal exceptions like Panic or InstallationError). Gghcidefile path of span < = > ? @ A B C D E F G H I J = < E D J I A > ? @ G H B F C-None"#$%147>MPX_k1 Sghcide"True if a module is a source inputTghcideElocate a module in the file system. Where we go from *daml to HaskellUghcideThis function is used to map a package name to a set of import paths. It only returns Just for unit-ids which are possible to import into the current module. In particular, it will return Nothing for main@ components as they can never be imported into another package.Vghcideelocate a module in either the file system or the package database. Where we go from *daml to HaskellWghcide"Don't call this on a found module.VghcideImport directoriesghcideFile extensionsghcidedoes file exist predicateghcide Moudle nameghcide Package nameghcideIs boot module XYZ[S\]^_`UV None"#$%147>MPX_kX? RghcideXTransitive module dependencies in topological order. The module itself is not included. SghcideXTransitive module dependencies in topological order. The module itself is not included. Tghcide1Transitive pkg dependencies in unspecified order.aghcideA processed node in the dependency graph. If there was any error during processing the node or any of its dependencies, this is an b. Otherwise it is a c. Ughcide4An error attached to a node in the dependency graph. VghcideThis 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. Wghcide3This module has an import that couldn t be located. YghcideThis 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).dghcide%Error when trying to locate a module. Zghcide\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. aghcideTContains a reverse mapping from a module to all those that immediately depend on it. bghcideBFor a non-error node, this contains the set of immediate pkg deps. cghcideMap from FilePath to FilePathId dghcide2Map from hs-boot file to the corresponding hs file eghcideBUnprocessed results that we find by following imports recursively.eghcideSet of  lsfghcide Map from  l lghcideFor 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. oghcideThe imports for a given module. qghcideeImports of a module in the current package and the file path of that module on disk (if we found it) rghcide8Transitive package dependencies unioned for all imports.gghcideGiven 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. |ghcide)Transitive reverse dependencies of a file3 K L M N O P Q T R S U X V W 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 { | }3 \ ] ^ _ ` a b c d o p q r e f g h i U X V W Y Z [ P Q T R S l m n K L M N O k s t w u v x z { } | j y.None"#$%147>MPX_kchghcide 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_actionh/None"#$%147>MPX_kjighcideGiven a file and some contents, apply any necessary preprocessors, e.g. unlit/cpp. Return the resulting buffer and the DynFlags it implies.jghcideDThis reads the pragma information directly from the provided buffer.kghcideERun (unlit) literate haskell preprocessor on a file, or buffer if setlghcideRun CPP on a filemghcideRun a preprocessor on a fileiNone"#$%147>MPSX_ksZ ghcideNote 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). ghcide2Events that are useful for gathering user metrics. 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.  0None"#$%147>MPX_kxnghcideName we use for debuggingoghcide%Priority with which to log the actionpghcide The payloadqghcideYou must call r to signal completionsghcide*Completely remove an action from the queuerghcide-Mark an action as complete when called after q. Has no effect otherwisetu vnwopxyqsrz{None"#$%1479;>MPSX_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. ghcide%Warnings emitted by the preprocessor. ghcide#Errors emitted by the preprocessor. ghcide+New parse tree emitted by the preprocessor. ghcidePreprocessor to run over all parsed source trees, generating a list of warnings and a list of errors, along with a new parse tree. ghcide+Setup a GHC session for a given file, e.g. Foo.hs. For the same ComponentOptionsv from hie-bios, the resulting function will be applied once per file. It is desirable that many files get the same  !, so that more IDE features work. 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. ghcideVDirectory where the shake database should be stored. For ghcide this is always set to j for now meaning we keep everything in memory but the daml CLI compiler uses this for incremental builds. ghcideSet to |, to create a directory of profiling reports. ghcideXWhether to enable additional lsp messages used by the test suite for checking invariants ghcide2Whether to report progress during long operations. ghcidethe ```language to use ghcide#whether to use new colon convention ghcideokeywords used for completions. These are customizable since DAML has a different set of keywords than Haskell. ghcide,Whether to defer type errors, typed holes and out of scope variables. Deferral allows the IDE to continue to provide features such as diagnostics and go-to-definition, in situations in which they would become unavailable because of the presence of type errors, holes or unbound variables. ghcide/Whether to typecheck the entire project on load ghcide0When to typecheck reverse dependencies of a file ghcideWhether to return result of parsing module with Opt_Haddock. Otherwise, return the result of parsing without Opt_Haddock, so that the parsed module contains the result of Opt_KeepRawTokenStream, which might be necessary for hlint. ghcidenIf given, it will be called right after setting up a new cradle, allowing to customize the Ghc options used ghcide3Returns the Ghc session and the cradle dependencies ghcide9Used as Shake key, versions must be unique and not reused}ghcideFrom !https://wiki.haskell.org/Keywords9  9  1None"#$%147>MPX_k:~ghcide6Locate the definition of the name at a given position.ghcide*Synopsis for the name at a given position.ghcideGiven a  2 attempt to find the location where it is defined.ghcide3Filter out spans which do not enclose a given point~None"#$%,147>EHMNPSVX_gk4 ghcide3If false, missing file diagnostics are not reportedghcide5This is what we use when we get Nothing from a rule.ghcideThis is used both for  as well as .ghcideRule type, input fileghcideInvariant: the vK must be in normal form (fully evaluated). Otherwise we keep repeatedly (ing values taken from the Shake databaseghcideWhen we depend on something that reported an error, and we fail as a direct result, throw BadDependency which short-circuits the rest of the action ghcide7A (maybe) stale result now, and an up to date one later ghcideVA Shake database plus persistent store. Can be thought of as storing mappings from  (FilePath, k) to  RuleResult k.ghcideSA live Shake session with the ability to enqueue Actions for running. Keeps the  open, so at most one  per database.ghcideCloses the Shake sessionghcideKey typeghcideThe state of the all values. $ghcide'A mapping of module name to known files .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 version First mapping is delta from previous version and second one is an accumlation of all previous mappings. 0ghcide(How many rules are running for each file 1ghcide(The generator for unique Lsp identifiers 2ghcideXWhether to enable additional lsp messages used by the test suite for checking invariants 3ghcideZUsed in the GhcSession rule to forcefully restart the session after adding a new component 4ghcideSReport progress about some long running operation (on top of the progress shown by lspShakeProgress) 5ghcideSame as  4>, but for processes that do not report the percentage complete 8ghcideKA mapping of module name to known target (or candidate targets, if missing) 9ghcideDA mapping of exported identifiers for local modules. Updated on kick :ghcide#A work queue for actions added via runInShakeSessionghcide2Convert 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.ghcidefReturn the most recent, potentially stale, value and a PositionMapping for the version of that value. Fghcide1Delete the value stored for a given ide build keyghcide^We return Nothing if the rule has not run and Just Failed if it has failed to produce a value. Gghcide Get all the files in the projectghcideSeq 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. HghcideOpen a  , should be shut using  J.ghcideThis is a variant of withMVar where the first argument is run unmasked and if it throws an exception, the previous value is restored while the second argument is executed masked. LghcideThese actions are run asynchronously after the current action is finished running. For example, to trigger a key build after a rule has already finished as is the case with useWithStaleFast MghcideRestart the current x with the given system actions. Any actions running in the current session will be aborted, but actions added via  N will be requeued. Nghcide"Enqueue an action in the existing b. Returns a computation to block until the action is run, propagating exceptions. Assumes a  is available..Appropriate for user actions other than edits.ghcide Set up a new E with a set of initial actions Will crash if there is an existing  running. Qghcide[FIXME: This function is temporary! Only required because the files of interest doesn't work RghcideFClear the results for all files that do not match the given predicate. Sghcide&Define a new Rule without early cutoff Tghcide"Request a Rule result if available UghcidecRequest a Rule result, it not available return the last computed result, if any, which may be stale Vghcide|Request a Rule result, it not available return the last computed result which may be stale. Errors out if none available. WghcidePlural version of  V XghcideIdeActions are used when we want to return a result immediately, even if it is stale Useful for UI actions like hover, completion where we don't want to block. ZghcideLookup value in the database and return with the stale value immediately Will queue an action to refresh the value. Might block the first time the rule runs, but never blocks after that. [ghcideCSame as useWithStaleFast but lets you wait for an up to date result `ghcidePlural version of  T aghcide5Return the last computed result which might be stale. bghcide#Define a new Rule with early cutoffghcideySets 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. ghcide8Large unit (platform dependent, do not make assumptions)ghcide8Small unit (platform dependent, do not make assumptions) Hghcidediagnostic handlerghcidecurrent resultsghcideGthe time that the file these diagnostics originate from was last editedi      ;                    ! " # $ % & + 4 5 , 0 3 ' ( ) * - . / 1 2 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 i jj   % & + 4 5 , 0 3 ' ( ) * - . / 1 2 6 7 8 9 : = > $ <    ;  ; H J M N I T \ ` Z [ L     ] ^ _ U a V W S b c d e O Q P  ? @ C B A D E   R G f g h i    j F   # "  ! K    X Y  None"#$%147=>?HMPVX_k ghcideMContains the typechecked module and the OrigNameCache entry for that module. ghcidewarning, the ModIface in the tm_checked_module_info of the TypecheckedModule will always be Nothing, use the ModIface in the HomeModInfo instead ghcide-Did we defer any type errors for this 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*ghcide(Generate byte code for template haskell.ghcideA GHC session that we reuse.ghcide1A GHC session preloaded with all the dependenciesghcidejRead the module interface file from disk. Throws an error for VFS files. This is an internal rule, use   instead.ghcideUGet a module interface details, either from an interface file or a typechecked moduleghcideUGenerate a ModSummary with the timestamps elided, for more successful early cutoffghcideGenerate a ModSummary that has enough information to be used to get .hi and .hie files. without needing to parse the entire source6 6 None"#$%147=>?HMPVX_k) Gghcide6The rule that initialises the files of interest state. Hghcide'Get the files that are open in the IDE. IghcidexSet the files-of-interest - not usually necessary or advisable. The LSP client will keep this information up to date. Jghcide{Modify the files-of-interest - not usually necessary or advisable. The LSP client will keep this information up to date. Kghcide9Typecheck all the files of interest. Could be improved G H I J K G H I J K None"#$%147>HMPVX_kYghcide|Processed DynFlags. Does not contain inplace packages such as local libraries. Can be used to actually load this Component.ghcideInternal units, such as local libraries, that this component is loaded with. These have been extracted from the original ComponentOptions.ghcideAll targets of this components.ghcide4Filepath which caused the creation of this componentghcide-Component Options used to load the component.ghcide"Maps cradle dependencies, such as  `stack.yaml`, or `.cabal`I file to last modification time. See Note [Multi Cradle Dependency Info]ghcidekUnprocessed DynFlags. Contains inplace packages such as libraries. We do not want to use them unprocessed.ghcideAll targets of this components.ghcide4Filepath which caused the creation of this componentghcide-Component Options used to load the component.ghcide"Maps cradle dependencies, such as  `stack.yaml`, or `.cabal`J file to last modification time. See Note [Multi Cradle Dependency Info]. Sghcide'Given a root directory, return a Shake   which setups an  2 given a file. Some of the many things this does:Find the cradle for the fileGet the session options,Get the GHC lib directory8Make sure the GHC compiletime and runtime versions matchRestart the Shake sessionThis is the key function which implements multi-component support. All components mapping to the same hie.yaml file are mapped to the same HscEnv which is updated as new components are discovered.ghcideRun the specific cradle on a specific FilePath via hie-bios. This then builds dependencies or whatever based on the cradle, gets the GHC options/dynflags needed for the session and the GHC library directoryghcide,Create a mapping from FilePaths to HscEnvEqsghcideSet the cache-directory based on the ComponentOptions and a list of internal packages. For the exact reason, see Note [Avoiding bad interface files].ghcide1Check if any dependency has been modified lately.ghcideComputes a mapping from a filepath to its latest modification date. See Note [Multi Cradle Dependency Info] why we do this ourselves instead of letting shake take care of it.ghcideThis function removes all the -package flags which refer to packages we are going to deal with ourselves. For example, if a executable depends on a library component, then this function will remove the library flag from the package flags for the executableThere are several places in GHC (for example the call to hptInstances in tcRnImports) which assume that all modules in the HPT have the same unit ID. Therefore we create a fake one and give them all the same unit id.ghcide1Memoize an IO function, with the characteristics:WIf multiple people ask for a result simultaneously, make sure you only compute it once.1If there are exceptions, repeatedly reraise them.FIf the caller is aborted (async exception) finish computing it anyway.ghcide)Throws if package flags are unsatisfiableghcide Sub directory for the cache pathghcideWrap any exception as a ghcide import paths S SNone"#$%147>MPX_dk[P Wghcide)Lsp client relevant configuration details W X Y Z [ \ ] ^ W X Y Z [ \ ^ ]None"#$%147>HMPVX_kkb aghcidehaskell-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 setBufferModified) we abstract over the VFS implementation. bghcide"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 modified gghcidelReturns the modification time and the contents. For VFS paths, the modification time is the current time. ighcideWNote that some buffer for a specific file has been modified but not with what changes. kghcideNote 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.ghcidefGet the contents of a file, either dirty (if the buffer is modified) or Nothing to mean use from disk. ighcideWas the file saved? a b c d e f g h i j k g b i k h f j a c d e2None "#$%147>HMPVX_k|eghcideA wrapper around a mutable ghcide%A map for tracking the file existenceghcide!Grab the current global value of  without acquiring a dependencyghcide&Modify the global store of file existsghcide&Modify the global store of file exists sghcideReturns True if the file exists Note that a file is not considered to exist unless it is saved to disk. In particular, VFS existence is not enough. Consider the following example: 1. The file A.hs containing the line import B1 is added to the files of interest Since B.hse is neither open nor exists, GetLocatedImports finds Nothing 2. The editor creates a new buffer B.hs( Unless the editor also sends a DidChangeWatchedFiley event, ghcide will not pick it up Most editors, e.g. VSCode, only send the event when the file is saved to disk.ghcide Installs the  s rules. Provides a fast implementation if client supports dynamic watched files. Creates a global state as a side effect in that case. sNone"#$%147=>?HMPSVX_k~ tghcide Initialise the Compiler Service. vghcideShutdown the Compiler Service.  D E O Q h j t u v w D E  t v w u O Q h jNone"#$%147>MPSX_dk x y z { | } ~  z { | } ~  x y3None"#$%147>MPSX_dk4None"#$%147>MPSX_kghcide>Whether we should run the -O0 simplifier when generating core.TThis is required for template Haskell to work but we disable this in DAML. See #256ghcideGGiven a string buffer, return the string (after preprocessing) and the L.ghcide;Given a package identifier, what packages does it depend onghcide*Compile a single type-checked module to a ` value, or provide errors.ghcideMSetup the environment that GHC needs according to our best understanding (!)BThis involves setting up the finder cache and populating the HPT.ghcideJInitialise the finder cache, dependencies should be topologically sorted.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.The order modules are loaded is important when there are hs-boot files. In particular you should make sure to load the .hs version of a file after the .hs-boot version.ghcideLoad module interface.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.ghcidexGiven a buffer, env and filepath, produce a module summary by parsing only the imports. Runs preprocessors as needed.ghcideParse only the module headerghcideGiven a buffer, flags, and file path, produce a parsed module (or errors) and any parse warnings. Does not run any preprocessorsghcideAfter parsing the module remove all package imports referring to these packages as we have already dealt with what they map to.ghcidegRetuns an up-to-date module interface, regenerating if needed. Assumes file exists. Requires the  to be set up with dependenciesghcide"Non-interactive, batch version of 56<. The interactive paths create problems in ghc-lib buildsghcide"Non-interactive, batch version of 57<. The interactive paths create problems in ghc-lib buildsghcide flags to useghcide#the filename (for source locations)ghcide6Haskell module source text (full Unicode is supported)ghcide flags to useghcideThe package imports to ignoreghcide#the filename (for source locations)ghcidethe modification timestampghcide6Haskell module source text (full Unicode is supported)ghcide!Action to regenerate an interfaceghcide%a moudle where the names are in scopeghcide%A module where the Names are in scope 8None"#$%147>MPSX_kghcide$Shows this part of the documentationghcideGiven a module finds the local dochtmlFoo-Bar-Baz.html2 page. An example for a cabal installed module: ~.cabalstore ghc-8.10.1vctr-0.12.1.2-98e2e861sharedochtmlData-Vector-Primitive.htmlghcide,Given a module finds the hyperlinked source dochtmlsrc/Foo.Bar.Baz.html2 page. An example for a cabal installed module: ~.cabalstore ghc-8.10.1vctr-0.12.1.2-98e2e861sharedochtmlsrc/Data.Vector.Primitive.htmlghcide3All of the possible modules it could be defined in.ghcide$The name you want documentation for.9None"#$%147>MPSX_k€ ghcide@Get source span info, used for e.g. AtPoint and Goto Definition.ghcide#Get ALL source spans in the module.ghcidehThe locations in the typechecked module are slightly messed up in some cases (e.g. HsMatchContext always points to the first match) whereas the parsed module has the correct locations. Therefore we build up a map from OccName to the corresponding definition in the parsed module to lookup precise locations for things like multi-clause function definitions.$For now this only contains FunBinds.ghcide:Variant of GHC's ieNames that produces LIdP instead of IdPghcide#Get the name and type of a binding.ghcide!Get information about constraintsghcide'Get the name and type of an expression.ghcide#Get the name and type of a pattern.ghcidePretty print the types into a >.ghcide!Dependencies in topological orderghcide%Dependencies parsed, optional if the  already contains docsghcideimports:None"#$%147>MPX_k ghcideA context of a declaration in the program e.g. is the declaration a type declaration or a value declaration Used for determining which code completions to show TODO: expand this with more contexts like classes or instances for smarter code completionghcidemodule context with module nameghcideimport context with module nameghcide$import list context with module nameghcide&import hiding context with module nameghcide4List of exported identifiers from the current moduleghcideGenerates a map of where the context is a type and where the context is a value i.e. where are the value decls and the type declsghcideAProduces completions from the top level declarations of a module.ghcideAReturns the cached completions for the given module and position.ghcidejUnder certain circumstance GHC generates some extra stuff that we don't want in the autocompleted symbolsghcide(Prefixes that can occur in a GHC OccNameNone"#$%147=>?HMPVX_dk ghcideRGiven the path to a module src file, this rule returns True if the corresponding `.hi`g file is stable, that is, if it is newer than the src file, and all its dependencies are stable too. ghcideThis 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. ghcideeuseE is useful to implement functions that aren t rules but need shortcircuiting e.g. getDefinition. ghcideZGet all transitive file dependencies of a given module. Does not include the file itself. ghcide/Try to get hover text for the name under point. ghcideGoto Definition. ghcide"Parse the contents of a daml file.ghcideIMPORTANT FOR HLINT INTEGRATION: We currently parse the module both with and without Opt_Haddock, and return the one with Haddocks if it -- succeeds. However, this may not work for hlint, and we might need to save the one without haddocks too. See  Fhttps://github.com/digital-asset/ghcide/pull/350#discussion_r370878197 and Chttps://github.com/mpickering/ghcide/pull/22#issuecomment-625070490ghcideGiven some normal parse errors (first) and some from Haddock (second), merge them. Ignore Haddock errors that are in both. Demote Haddock-only errors to warnings.ghcideaGiven a target file path, construct the raw dependency results by following imports recursively. ghcide)A rule that wires per-file rules togetherghcidefile we're editingghcidemodule dep we want info forghcidehie stuff for the moduleghcide$Package Module to load .hie file forghcide0Path of home module importing the package moduleghcide$Should generate .hi and .hie files ? P Q T R S  w   P Q T R S w ;None"#$%147>MPX_kh None"#$%147>MPX_k ghcideMPrefix to uniquely identify commands sent to the client. This has two partsA representation of the process id to make sure that a client has unique commands if it is running multiple servers, since some clients have a global command table and get confused otherwise.A string to identify ghcide, to ease integration into haskell-language-server, which routes commands to plugins based on that. ghcideGet the operating system process id for the running server instance. This should be the same for the lifetime of the instance, and different from that of any other currently running instance.  None"#$%1479;>MPX_k ghcide:: Null ghcide :: String ghcide :: Number  None"#$%147>HMPVX_k ghcideGenerate code actions.ghcide#Produce completions info for a file  None"#$%147>MPX_dk ghcide/a command that blocks forever. Used for testing ghcideGenerate code actions. ghcideGenerate code lenses. ghcide(Execute the "typesignature.add" command.ghcideAll the GHC extensions ghcide {getIndentedGroupsBy (" H" `isPrefixOf`) [" H1", " l1", " l2", " H2", " l3"] = [[" H1", " l1", " l2"], [" H2", " l3"]] ghcideJSuggests a constraint for a declaration for which a constraint is missing. ghcideTSuggests a constraint for an instance declaration for which a constraint is missing. ghcideMSuggests a constraint for a type signature for which a constraint is missing. ghcideDSuggests the removal of a redundant constraint for a type signature.ghcideIf a range takes up a whole line (it begins at the start of the line and there's only whitespace between the end of the range and the next newline), extend the range to take up the whole line.ghcideReturns [start .. end[ghcide9Returns the ranges for a binding in an import declarationghcideExtends an import list with a new binding. Assumes an import statement of the form: import (qualified) A (..) .. Places the new binding first, preserving whitespace. Copes with multi-line import listsghcide combined with ghcide@Returns Just (the submatches) for the first capture, or Nothing.  None"#$%147>MPX_dkHghcideWrap the Document imports into a hierarchical outline for a better overview of symbols in scope. If there are no imports, then no hierarchy will be created.  None"#$%147>MPX_kghcide6Respond to and log a hover or go-to-definition request  None"#$%147>EMPSX_k"ghcideA 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)ghcide~Used for cases in which we need to send not only a response, but also an additional request to the client. For example, executeCommand may generate an applyWorkspaceEdit request.ghcide]Used for the InitializeRequest only, where the response is generated by the LSP core handler.ghcideeThings that get sent to us, but we don't deal with. Set them to avoid a warning in VS Code output.  None"#$%147>MPX_k#                                   ! " # < = > ? @ A B C D E F G H I J  ;           % S T U V X Z [ \ ] ^ _ ` b h i H W X Y ^ g s w                                    ! " # < = > ? @ A B C D E F G H I J  ; ;           % S T U V X Z [ \ ] ^ _ ` b h i H W X Y ^ g s w <=><=?<=@<=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<=i<=j<=k<=l<=m<=n<=o<=p<=q<=r<=s<=t<=u<=v<=w<=x<=y<=z<={<=|<=}<=~<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<=<<<<<<<<<5<5<5<5<5<5<5<5<5<5<5<56<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<5<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<<< <!<"<#<$<%<%<&'<&(<&)<&*<&+<&,<&-<&-<./<.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<.i<.j<.k<.l<.m<.n<.o<.p<.q<.r<.s<.t<.u<.v<.w<.x<.y<.z<.{<.|<.}<.~<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<< <!<"<#<$<%<&<'<(<)<*<+<,<-<.</<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<W<X<X<Y<Z<[<\<]<^<_<`<a<a<b<c<d<e<f<g<h<h<i<j<k<l<m<n<o<p<p<q<r<s<t<u<v<w<x<y<z<{<|<}<~<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<< <!<"<"<#<$<%<%<&<'<(<)<*<+<,<-<.</<0<1<2<3<4<5<6<7<8<9<:<;<<<=<><?<@<@<A<B<C<D<E<F<F<G<H<I<J<K<L<M<N<O<P<Q<R<S<T<U<V<V<W<X<X<Y<Z<[<\<]<^<_<`<a<b<c<d<e<e<f<g<h<i<j<k<l<l<m<n<o<p<q<r<s<t<u<v<w<x<y<z<{<|<}<~<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<< <!<"<#<$<%<&<'<(<(<)<*<+<,<,<-<.</<0<1<2<3<4<0<5<67<68<69<6:<6;<6<<6=<6><6?<6@<6A<6B<6C<6D<6E<6F<6G<6H<6I<6J<6K<6L<6M<6N<6O<6P<6Q<6R<6S<6T<6U<6V<6W<6X<6Y<6Z<6[<6\<6]<6^<6_<6`<6a<6b<6c<6d<6e<6f<6g<6h<6i<6j<6k<6l<6m<6n<6o<6p<6q<6r<6s<6t<6u<6v<6w<6x<6y<6z<6{<6|<6}<6~<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6`<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<6<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<<< < <!<"<#<$<%<&<'<(<)<)<*<+<,<-<.</<0<1<2<3<4<5<6<7<8<9<:<;<<<=<><?<@<A<B<C<D<E<F<G<H<I<J<K<L<M<5<N<O<P<Q<R<S<T<U<V<V<W<X<Y<Z<[<\<]<]<^<_<`<a<b<c<d<e<f<f<g<h<i<j<kl<km<kn<ko<kp<kp<kq<kr<ks<kr<kt<ku<kv<kw<kx<ky<kz<k{<k|<k}<k~<k<k<k<k<k<k<k<k<k<k<k<k<k<k<k<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<1<11<1<1<1<1<1<12<1<1<1<1<1<1<1<1<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<m<<<<<<<<<< < < < < <<<<<<<<<<<<<<<<<<<< <!<"<#<$<%<&<%<'<(<)*<)+<)+<),<)-<).<)/<)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<)i<)j<)k<)l<)m<)n<)o<)p<)$<)q<)r<)s<)t<)u<)v<)w<)x<)y<)z<){<)|<)}<)~<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)V<)<)<)<)<)<)<)<)<) <) <) <) <) <)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<)<) <)!<)"<)#<)$<)<)%<)&<)'<)(<))<)*<)+<),<)-<).<)/<)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<)i<)j<)k<)l<)m<)n<)o<)p<)q<)r<)\<)s<)t<)u<)v<)w<)x<)y<)z<){<)|<)}<)~<)<)<)<)<)<)<)<)<)<)<)<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< < < < < < <  <<<<<<<<<<<<<<<<< !< "< #< $< %< &<'(<')<'*<'+<',<'-<'.<'/<'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<'i<'j<'k<'l<'m<'n<'o<'p<'q<'r<'s<'t<'u<'v<'w<'x<'y<'z<'{<'|<'}<'~<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<'<' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' <' !<' "<' #<' $<' %<' &<' '<' (<' )<' *<' +<' ,<' -<' .<' /<' 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<' i<' j<' k<' l<' m<''<' n<' o<' p<' q<' r<' s<' t<' u<' v<' w<' x<' y<' z<' {<' |<' }< ~ < < < < < < < < <  < < < < < < <  <  <  <  <  <  <  <  <  <  <  <  <  <  < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < <  <  <  <  < <  <  <  <  <  <  <  << < < < < <  < < <  <  <  < <<' <' <' <''<' < < <  <  <  <  <  <  <  <  <  <  <  <  < < <                                                              ! " # # $ $ % & ' ( ) * + , - . / 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  e f g  h  i  j  j k l m  n  o p q r  s  s t  u  u  v  w  x  y  z  {  |  }  ~          ! ! ! ! ! ! ! " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " " $                                                                                     ! " # $ % & ' ( ) * +  ,  , - . / 0  1  1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K  L  L M N O  P  P Q R S  T  U  V  W  X  Y  Y  Z  Z [ \ ] ^ _ ` a  b  b c d e  f  g  h  h i  j  j k l m n o p q r s t u v w x y z { | } ~                     0                                                                                                                                       !  " # $ % & ' ( ) * + , - . / 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 i j k l m n o p q r s t u v w x y z z { { | | } } ~ ~                                                                                                                                                                                  ! " # $ % & ' ( ) ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C2 D E F G H I I J J K L M N O P Q R R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n; o p p q r s t u v w x y z { | } ~    ~                    ~                  <   <  ! ! ! !  ! <   ! ! ! !  # # # # # # # # # # # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ % % % & <' & ' ' ' '  ' ' ' ' ' ( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ))))<<  <    *************** * *!*"*#+$+$-%-&-'-(-)-*-*-+-,- V---.-/-0 1 2 3 4 5 6 7.8/9/:/;/</=0>0?0@0A0B0C0D0E0 0F0G0H0I0J KL1 1M1N1O1 PQ  RSTUVWX YZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~222222344i44444444444444444h4444444888888999999999::::::::::::::#ghcide-0.4.0-98cFz095V7v2i8ymOuBUUoDevelopment.IDE.GHC.CompatDevelopment.IDE.GHC.Util!Development.IDE.Types.DiagnosticsDevelopment.IDE.Types.LocationDevelopment.IDEDevelopment.IDE.CompatDevelopment.IDE.Core.Debouncer$Development.IDE.Core.PositionMappingDevelopment.IDE.Spans.CommonDevelopment.IDE.LSP.ProtocolDevelopment.IDE.Types.ExportsDevelopment.IDE.GHC.Error,Development.IDE.Import.DependencyInformationDevelopment.IDE.Types.LoggerDevelopment.IDE.Core.ShakeDevelopment.IDE.Types.OptionsDevelopment.IDE.Core.RuleTypesDevelopment.IDE.Core.OfInterestDevelopment.IDE.Session%Development.IDE.Core.IdeConfigurationDevelopment.IDE.Core.FileStoreDevelopment.IDE.Core.ServiceDevelopment.IDE.LSP.ServerDevelopment.IDE.Core.Rules!Development.IDE.Plugin.CodeActionDevelopment.IDE.PluginDevelopment.IDE.Plugin.Test"Development.IDE.Plugin.CompletionsDevelopment.IDE.LSP.Outline#Development.IDE.LSP.HoverDefinition"Development.IDE.LSP.LanguageServerDevelopment.IDE.GHC.HieTypesDevelopment.IDE.GHC.HieBinDevelopment.IDE.GHC.HieUtilsDevelopment.IDE.GHC.HieDebugDevelopment.IDE.GHC.HieAstDevelopment.IDE.GHC.CPP Development.IDE.GHC.WithDynFlags1Development.IDE.Plugin.CodeAction.PositionIndexed$Development.IDE.Session.VersionCheck(Development.IDE.Plugin.Completions.TypesDevelopment.IDE.Spans.Type+Development.IDE.Plugin.CodeAction.RuleTypesDevelopment.IDE.GHC.Orphans"Development.IDE.Import.FindImportsDevelopment.IDE.GHC.Warnings!Development.IDE.Core.PreprocessorDevelopment.IDE.Types.ActionDevelopment.IDE.Spans.AtPointDevelopment.IDE.Core.FileExists!Development.IDE.LSP.NotificationsDevelopment.IDE.Core.CompileInteractiveEvalgetDocs lookupNames#Development.IDE.Spans.DocumentationDevelopment.IDE.Spans.Calculate(Development.IDE.Plugin.Completions.Logic'Development.IDE.Plugin.CodeAction.RulesghcGHCparserobtainTermFromIdobtainTermFromValgetHistorySpan getGHCiMonad setGHCiMonadmoduleTrustReqsisModuleTrusted lookupModule findModuleshowRichTokenStreamaddSourceToTokensgetRichTokenStreamgetTokenStreampprParenSymName dataConTypegetNameToInstancesIndexgetGREfindGlobalAnnslookupGlobalName isDictonaryIdmodInfoModBreaks modInfoSafe modInfoIfacemodInfoLookupNamemkPrintUnqualifiedForModulemodInfoIsExportedNamemodInfoInstancesmodInfoExportsWithSelectorsmodInfoExportsmodInfoTopLevelScopemodInfoTyThings getModuleInfogetPrintUnqualgetInsts getBindingsisLoadedgetModuleGraphcompileToCoreSimplifiedcompileToCoreModule loadModule desugarModuletypecheckModule parseModule getModSummaryworkingDirectoryChanged guessTarget removeTarget addTarget getTargets setTargetsparseDynamicFlagsgetInteractiveDynFlagssetInteractiveDynFlagsgetProgramDynFlags setLogActionsetProgramDynFlagssetSessionDynFlags initGhcMonadwithCleanupSessionrunGhcTrunGhcdefaultCleanupHandlerdefaultErrorHandler parsedSource ParsedMod moduleInfotypecheckedSource renamedSourceTypecheckedMod coreModulepm_annotationspm_extra_src_filespm_parsed_sourcepm_mod_summary ParsedModule tm_internals_tm_checked_module_infotm_typechecked_sourcetm_renamed_sourcetm_parsed_moduleTypecheckedModuledm_core_moduledm_typechecked_moduleDesugaredModule ParsedSource RenamedSourceTypecheckedSourcecm_safecm_bindscm_types cm_module CoreModule ModuleInfoGhcMakecyclicModuleErrtopSortModuleGraphloaddepanalLoadDependenciesOfLoadUpToLoadAllTargets LoadHowMuchreconstructTypemoduleIsBootOrNotObjectLinkable showModuledynCompileExprcompileParsedExprcompileParsedExprRemotecompileExprRemote compileExpr parseExprtypeKindexprTypeisDeclisImport hasImportisStmt parseNamegetRdrNamesInScopegetNamesInScopegetInfomoduleIsInterpreted getContext setContext abandonAllabandonforwardback resumeExecparseImportDeclrunDeclsWithLocationrunDeclsexecStmt execOptionsgetHistoryModulegetResumeContextInteractiveName NoDocsInIfaceNameHasNoModuleGetDocsFailure TcRnDriverrunTcInteractive TM_Default TM_NoInstTM_Inst TcRnExprMode PprTyThing pprFamInstGhcMonaddefaultWarnErrLoggerprintExceptiongetSessionDynFlags setSession getSessionGhcGhcT WarnErrLoggerIfaceEnvupdateNameCacheNCUNameCacheUpdaterHscTypes ms_mod_name mkModuleGraphemptyMGmgLookupModulemgModSummariesmapMGneedsTemplateHaskellOrQQhandleSourceErrorHscEnvtargetContentstargetAllowObjCodetargetIdTarget TargetFile TargetModuleTargetId mi_arg_docs mi_decl_docs mi_doc_hdrmi_complete_sigs mi_trust_pkgmi_trustmi_hpc mi_hash_fn mi_fix_fn mi_warn_fnmi_orphan_hashmi_rules mi_fam_instsmi_insts mi_globalsmi_declsmi_annsmi_warns mi_fixities mi_used_th mi_exp_hash mi_exports mi_usagesmi_deps mi_hsc_src mi_finsts mi_orphanmi_plugin_hash mi_hpc_hash mi_opt_hash mi_flag_hash mi_mod_hash mi_iface_hash mi_sig_of mi_moduleModIfaceIIModuleIIDeclInteractiveImport ModuleGraph ms_hspp_buf ms_hspp_opts ms_hspp_file ms_parsed_modms_textual_imps ms_srcimps ms_iface_date ms_obj_date ms_hs_date ms_location ms_hsc_srcms_mod ModSummaryHsSynhsmodHaddockModHeaderhsmodDeprecMessage hsmodDecls hsmodImports hsmodExports hsmodNameHsModuleHsUtils lPatImplicitshsValBindsImplicitslStmtsImplicitshsDataFamInstBindersgetPatSynBindshsPatSynSelectorshsForeignDeclsBindershsLTyClDeclBindershsTyClForeignBindershsGroupBinderscollectPatsBinderscollectPatBinderscollectStmtBinderscollectLStmtBinderscollectStmtsBinderscollectLStmtsBinderscollectMethodBinderscollectHsBindListBinderscollectHsBindsBinderscollectHsBindBinderscollectHsValBinderscollectHsIdBinderscollectLocalBindersisBangedHsBindisUnliftedHsBindmkMatchmkPrefixFunRhsmk_easy_FunBindisInfixFunBind mkPatSynBind mkVarBind mkHsVarBind mkTopFunBind mkFunBind mkHsDictLet mkHsWrapPatCo mkHsWrapPat mkLHsCmdWrap mkHsCmdWrap mkLHsWrapCo mkHsWrapCoR mkHsWrapComkHsWrap mkLHsWrap typeToLHsType mkClassOpSigs mkHsSigEnvmkLHsSigWcType mkLHsSigTypechunkify mkChunkifiedmkBigLHsPatTupmkBigLHsVarPatTup mkBigLHsTupmkBigLHsVarTup missingTupArg nlTuplePat mkLHsVarTuplemkLHsTupleExpr nlHsTyConApp nlHsParTy nlHsFunTy nlHsTyVar nlHsAppTynlListnlHsCasenlHsIfnlHsParnlHsLam nlHsOpAppnlHsDo nlWildPatName nlWildPat nlWildConPatnlNullaryConPat nlConPatNamenlConPat nlInfixConPatnlConVarPatName nlConVarPat nlHsVarAppsnlHsAppsnlHsSyntaxAppsnlHsAppnlLitPatnlVarPat nlHsIntLitnlHsLit nlHsDataConnlHsVaruserHsTyVarBndrsuserHsLTyVarBndrsmkHsStringPrimLit mkHsStringunqualQuasiQuotemkHsQuasiQuote mkHsSpliceTy mkHsSpliceTE mkHsSpliceEmkUntypedSplice mkHsOpApp mkRecStmtemptyRecStmtIdemptyRecStmtName emptyRecStmt unitRecStmtTc mkTcBindStmt mkBindStmt mkBodyStmt mkLastStmtmkGroupByUsingStmtmkGroupUsingStmtmkTransformByStmtmkTransformStmtemptyTransStmt mkNPlusKPatmkNPatmkHsIfmkHsCompmkHsDo mkHsIsStringmkHsFractional mkHsIntegralnlParPatmkParPatmkLHsPar nlHsTyApps nlHsTyApp mkHsCaseAltmkHsLamsmkHsLam mkHsAppTypes mkHsAppTypemkHsApp mkMatchGroup unguardedRHSunguardedGRHSs mkSimpleMatchmkHsParHsExpr pprStmtInCtxtpprMatchInCtxtmatchContextErrStringpprStmtContextpprAStmtContextpprMatchContextNounpprMatchContextmatchSeparatorisMonadFailStmtContextisListCompExpr isPatSynCtxt pp_dotdot thTyBrackets thBrackets pprHsBracketisTypedBracket ppr_splice ppr_quasippr_splice_declpprPendingSplice isTypedSplicepprQualspprComp ppr_do_stmtspprDopprBy pprTransStmtpprTransformStmtpprStmtpp_rhspprGRHSpprGRHSspprMatch pprMatches hsLMatchPatsmatchGroupArityisSingletonMatchGroupisEmptyMatchGroup isInfixMatch pprCmdArgppr_cmdppr_lcmd isQuietHsCmdpprCmdpprLCmdisAtomicHsExprparenthesizeHsExprhsExprNeedsParens pprParendExprpprParendLExprpprDebugParendExprpprExternalSrcLocppr_appsppr_expr ppr_lexprpprBinds isQuietHsExpr tupArgPresent unboundVarOccmkRnSyntaxExpr noSyntaxExprnoExpr PostTcExpr PostTcTable syn_res_wrap syn_arg_wrapssyn_expr SyntaxExprCmdSyntaxTable TrueExprHole OutOfScope UnboundVar rupd_flds rupd_exprrupd_ext rcon_flds rcon_con_namercon_extXExprHsWrapELazyPatEViewPatEAsPatEWildPat HsTickPragma HsBinTickHsTick HsArrFormHsArrAppHsStaticHsProc HsSpliceEHsTcBracketOutHsRnBracketOut HsBracket HsCoreAnnHsSCCArithSeq ExprWithTySig RecordUpd RecordCon ExplicitListHsDoHsLet HsMultiIfHsIfHsCase ExplicitSum ExplicitTupleSectionRSectionLHsParNegAppOpApp HsAppTypeHsApp HsLamCaseHsLamHsLit HsOverLitHsIPVar HsOverLabelHsRecFld HsConLikeOut HsUnboundVarHsVar rcon_con_expr rcon_con_like RecordConTc rupd_wrap rupd_out_tys rupd_in_tys rupd_cons RecordUpdTc LHsTupArgXTupArgMissingPresentHsTupArgLHsCmdXCmd HsCmdWrapHsCmdDoHsCmdLetHsCmdIf HsCmdCaseHsCmdParHsCmdLamHsCmdApp HsCmdArrForm HsCmdArrAppHsFirstOrderAppHsHigherOrderApp HsArrAppType LHsCmdTopXCmdTopHsCmdTopCmdTopTc HsRecordBinds mg_originmg_altsmg_ext XMatchGroupMG mg_res_ty mg_arg_tys MatchGroupTcLMatchm_grhssm_patsm_ctxtm_extXMatchMatchgrhssLocalBinds grhssGRHSsgrhssExtXGRHSsGRHSsLGRHSXGRHSGRHSLStmtLStmtLRStmtCmdLStmtCmdStmt ExprLStmtExprStmt GuardLStmt GuardStmt GhciLStmtGhciStmt recS_mfix_fn recS_ret_fn recS_bind_fn recS_rec_idsrecS_later_ids recS_stmtsrecS_exttrS_fmaptrS_bindtrS_rettrS_by trS_using trS_bndrs trS_stmtstrS_formtrS_extXStmtLRRecStmt TransStmtParStmtLetStmtBodyStmtApplicativeStmtBindStmtLastStmtStmtLR recS_ret_ty recS_rec_retsrecS_later_rets recS_bind_ty RecStmtTc GroupFormThenForm TransForm XParStmtBlock ParStmtBlockXApplicativeArgApplicativeArgManyApplicativeArgOneApplicativeArgXSplice HsSpliced HsQuasiQuoteHsUntypedSplice HsTypedSpliceNoParens HasDollar HasParensSpliceDecorationThModFinalizers HsSplicedPat HsSplicedTy HsSplicedExprHsSplicedThingSplicePointNamePendingRnSpliceUntypedDeclSpliceUntypedTypeSpliceUntypedPatSpliceUntypedExpSpliceUntypedSpliceFlavourPendingTcSpliceXBracketTExpBrVarBrTypBrDecBrGDecBrLPatBrExpBr FromThenToFromToFromThenFrom ArithSeqInfo mc_strictness mc_fixitymc_funPatSyn ThPatQuote ThPatSpliceStmtCtxtRecUpd PatBindGuards PatBindRhsProcExprIfAltCaseAlt LambdaExprFunRhsHsMatchContext TransStmtCtxt ParStmtCtxtPatGuard GhciStmtCtxt ArrowExprMDoExprDoExpr MonadCompListComp HsStmtContextHsDeclsroleAnnotDeclNameannProvenanceName_maybe docDeclDocpprFullRuleNamecollectRuleBndrSigTysflattenRuleDeclsderivStrategyNameinstDeclDataFamInsts pprFamInstLHSpprDataFamInstFlavourhsConDeclThetahsConDeclArgTys getConNamesnewOrDataToFlavourresultVariableNamefamDeclHasCusk mkTyClGrouptyClGroupRoleDeclstyClGroupInstDeclstyClGroupTyClDeclsemptyTyClGrouppprTyClDeclFlavour hsDeclHasCuskcountTyClDeclstyClDeclTyVarstcdName tyClDeclLNametyFamInstDeclLNametyFamInstDeclNameisDataFamilyDeclisClosedTypeFamilyInfoisOpenTypeFamilyInfoisTypeFamilyDecl isFamilyDecl isClassDecl isSynDecl isDataDecl appendGroupshsGroupInstDecls emptyRnGroup emptyRdrGroupLHsDeclXHsDecl RoleAnnotDDocDSpliceDRuleDAnnDWarningDDefDHsDeclhs_docs hs_ruledshs_annds hs_warndshs_fordshs_defdshs_fixds hs_derivds hs_tyclds hs_splcdshs_valdshs_extXHsGroupHsGroup LSpliceDecl XSpliceDecl SpliceDecl LTyClDecltcdDocs tcdATDefstcdATstcdMethstcdSigstcdFDstcdCtxttcdCExt tcdDataDefntcdDExttcdRhs tcdFixity tcdTyVarstcdLNametcdSExttcdFamtcdFExt XTyClDecl ClassDeclDataDeclSynDeclFamDeclTyClDecltcdFVs tcdDataCusk DataDeclRn group_instds group_roles group_tyclds group_ext XTyClGroup TyClGroupLFamilyResultSigXFamilyResultSigTyVarSigKindSigNoSigFamilyResultSig LFamilyDeclfdInjectivityAnn fdResultSigfdFixityfdTyVarsfdLNamefdInfofdExt XFamilyDecl FamilyDeclLInjectivityAnnInjectivityAnnClosedTypeFamilyOpenTypeFamily DataFamily FamilyInfo dd_derivsdd_cons dd_kindSigdd_cTypedd_ctxtdd_NDdd_ext XHsDataDefn HsDataDefn HsDerivingLHsDerivingClausederiv_clause_tysderiv_clause_strategyderiv_clause_extXHsDerivingClauseHsDerivingClauseDataTypeNewType NewOrDataLConDecl con_ex_tvscon_namecon_extcon_doc con_res_tycon_args con_mb_cxt con_qvars con_forall con_names con_g_extXConDecl ConDeclH98 ConDeclGADTConDeclHsConDeclDetails LTyFamInstEqnLTyFamDefltEqnHsTyPats TyFamInstEqn TyFamDefltEqnLTyFamInstDecltfid_eqn TyFamInstDeclLDataFamInstDecldfid_eqnDataFamInstDecl LFamInstEqn FamInstEqnfeqn_rhs feqn_fixity feqn_pats feqn_tyconfeqn_extXFamEqnFamEqn LClsInstDeclcid_overlap_modecid_datafam_instscid_tyfam_instscid_sigs cid_binds cid_poly_tycid_ext XClsInstDecl ClsInstDecl LInstDecl tfid_insttfid_ext dfid_instdfid_extcid_inst cid_d_ext XInstDecl TyFamInstD DataFamInstDClsInstDInstDecl LDerivDeclderiv_overlap_modederiv_strategy deriv_type deriv_ext XDerivDecl DerivDeclLDerivStrategy ViaStrategyNewtypeStrategyAnyclassStrategy StockStrategy DerivStrategy LDefaultDecl XDefaultDecl DefaultDecl LForeignDeclfd_fefd_e_extfd_fi fd_sig_tyfd_namefd_i_ext XForeignDecl ForeignExport ForeignImport ForeignDeclCImportCWrapper CFunctionCLabel CImportSpecCExport LRuleDecls rds_rulesrds_srcrds_ext XRuleDeclsHsRules RuleDecls LRuleDecl XRuleDeclHsRuleRuleDeclHsRuleRn LRuleBndr XRuleBndr RuleBndrSigRuleBndrLDocDeclDocGroupDocCommentNamedDocCommentPrevDocCommentNextDocDecl LWarnDecls wd_warningswd_srcwd_ext XWarnDeclsWarnings WarnDecls LWarnDecl XWarnDeclWarningWarnDeclLAnnDeclXAnnDecl HsAnnotationAnnDeclModuleAnnProvenanceTypeAnnProvenanceValueAnnProvenance AnnProvenanceLRoleAnnotDeclXRoleAnnotDecl RoleAnnotDeclHsPatcollectEvVarsPatcollectEvVarsPatsparenthesizePatpatNeedsParensisIrrefutableHsPatlooksLazyPatBind isBangedLPat mkCharLitPatmkNilPatmkPrefixConPat pprConArgs pprParendLPathsRecUpdFieldOcchsRecUpdFieldIdhsRecUpdFieldRdr hsRecFieldId hsRecFieldSelhsRecFieldsArgs hsRecFields hsConPatArgsInPatOutPatpat_wrappat_args pat_binds pat_dictspat_tvs pat_arg_tyspat_conXPatCoPatSigPat NPlusKPatNPatLitPat SplicePatViewPat ConPatOutConPatInSumPatTuplePatListPatBangPatParPatAsPatLazyPatWildPat ListPatTcHsConPatDetails rec_dotdotrec_flds HsRecFields LHsRecField' LHsRecFieldLHsRecUpdField HsRecField HsRecUpdFieldhsRecPun hsRecFieldArg hsRecFieldLbl HsRecField'HsBinds pprMinimalSigpprTcSpecPragspprSpec pprVarSigpragSrcBrackets pragBracketsppr_sighsSigDocisCompleteMatchSig isSCCFunSig isMinimalLSig isInlineLSig isPragLSigisSpecInstLSig isSpecLSig isTypeLSig isFixityLSigisDefaultMethod hasSpecPrags noSpecPragsisEmptyIPBindsTcisEmptyIPBindsPRpprTicks ppr_monobindplusHsValBindsisEmptyLHsBinds emptyLHsBindsemptyValBindsOutemptyValBindsInisEmptyValBindseqEmptyLocalBindsisEmptyLocalBindsPRisEmptyLocalBindsTcemptyLocalBinds pprDeclListpprLHsBindsForUser pprLHsBinds HsLocalBinds LHsLocalBindsXHsLocalBindsLREmptyLocalBinds HsIPBindsHsLocalBindsLRLHsLocalBindsLR XValBindsLR HsValBindsLR NValBinds NHsValBindsLRLHsBindLHsBindsHsBind LHsBindsLR LHsBindLRabs_sig abs_binds abs_ev_binds abs_exports abs_ev_varsabs_tvsabs_ext var_inlinevar_rhsvar_idvar_ext pat_tickspat_rhspat_lhspat_extfun_tick fun_co_fn fun_matchesfun_idfun_ext XHsBindsLRAbsBindsVarBindPatBindFunBindHsBindLR pat_rhs_typat_fvs NPatBindTc abe_pragsabe_wrapabe_monoabe_polyabe_ext XABExportABEABExportpsb_dirpsb_defpsb_argspsb_idpsb_ext XPatSynBindPSB XHsIPBindsIPBindsLIPBindXIPBindIPBindLSigXSigCompleteMatchSig SCCFunSig MinimalSig SpecInstSigSpecSig InlineSigFixSigIdSig PatSynSigSig LFixitySig XFixitySig FixitySig SpecPragsIsDefaultMethod TcSpecPrags LTcSpecPragSpecPrag TcSpecPragHsPatSynDetailsrecordPatSynPatVarrecordPatSynSelectorIdRecordPatSynFieldExplicitBidirectionalImplicitBidirectionalUnidirectional HsPatSynDirInstEnvpprInstanceHdr pprInstanceinstanceDFunIdClsInst FamInstEnvFamInst ByteCodeTypes BreakIndexmodBreaks_breakInfo modBreaks_ccsmodBreaks_declsmodBreaks_varsmodBreaks_locsmodBreaks_flags ModBreaksHsTypesparenthesizeHsTypehsTypeNeedsParens pprHsTypepprConDeclFieldspprHsContextMaybepprHsContextNoArrow pprHsContextpprHsForAllTvspprHsForAllExtra pprHsForAllpprAnonWildCardambiguousFieldOccunambiguousFieldOccselectorAmbiguousFieldOccrdrNameAmbiguousFieldOccmkAmbiguousFieldOcc mkFieldOccgetLHsInstDeclClass_maybegetLHsInstDeclHeadsplitLHsInstDeclTysplitLHsQualTysplitLHsForAllTysplitLHsSigmaTysplitLHsPatSynTy splitHsAppTyshsTyGetAppHead_maybesplitHsFunType mkHsAppTys mkHsAppTymkHsOpTymkAnonWildCardTy isLHsForAllTy ignoreParens sameWildCard wildCardNamehsLTyVarBndrsToTypeshsLTyVarBndrToTypehsLTyVarLocNameshsLTyVarLocNamehsAllLTyVarNameshsExplicitLTyVarNames hsLTyVarName hsTyVarName hsScopedTvs hsWcScopedTvshsTvbAllKindedisHsKindedTyVar hsIPNameFSmkEmptyWildCardBndrsmkEmptyImplicitBndrsmkHsWildCardBndrsmkHsImplicitBndrs dropWildCards hsSigWcType hsSigTypehsImplicitBodyisEmptyLHsQTvs emptyLHsQTvs hsQTvExplicitmkHsQTvsgetBangStrictness getBangType LBangTypeBangType LHsContext HsContextLHsTypeHsKindLHsKind LHsTyVarBndr hsq_explicithsq_ext XLHsQTyVarsHsQTvs LHsQTyVars hsq_dependent hsq_implicitHsQTvsRn hsib_bodyhsib_extXHsImplicitBndrsHsIBHsImplicitBndrs hsib_closed hsib_varsHsIBRn hswc_bodyhswc_extXHsWildCardBndrsHsWCHsWildCardBndrs LHsSigType LHsWcType LHsSigWcTypeHsIPName XTyVarBndr KindedTyVar UserTyVar HsTyVarBndrhst_ctxt hst_xqualhst_body hst_bndrs hst_xforallXHsType HsWildCardTyHsTyLitHsExplicitTupleTyHsExplicitListTyHsRecTyHsBangTyHsDocTy HsSpliceTy HsKindSigHsStarTy HsIParamTyHsParTyHsOpTyHsSumTy HsTupleTyHsListTyHsFunTyHsAppTyHsTyVarHsQualTy HsForAllTyHsType NHsCoreTy NewHsTypeXHsStrTyHsNumTy AnonWildCardHsWildCardInfoHsBoxedOrConstraintTupleHsConstraintTuple HsBoxedTupleHsUnboxedTuple HsTupleSort NotPromotedPromoted LConDeclField cd_fld_doc cd_fld_type cd_fld_names cd_fld_ext XConDeclField ConDeclFieldInfixConRecCon PrefixCon HsConDetails LFieldOccrdrNameFieldOcc extFieldOcc XFieldOccFieldOccXAmbiguousFieldOcc Ambiguous UnambiguousAmbiguousFieldOccInteractiveEvalTypesexecWrapexecLineNumberexecSourceFileexecSingleStep ExecOptionsRunAndLogSteps SingleStepRunToCompletion breakInfo breakNamesexecAllocation execResult ExecBreak ExecComplete ExecResultbreakInfo_numberbreakInfo_module BreakInforesumeHistoryIx resumeHistory resumeCCS resumeDecl resumeSpanresumeBreakInfo resumeApStackresumeFinalIdsresumeBindings resumeContext resumeStmtResumehistoryEnclosingDeclshistoryBreakInfoHistoryId isBottomingId isDeadBinder isImplicitId idDataConisDataConWorkId isFCallId isPrimOpIdisClassOpId_maybeisRecordSelectorrecordSelectorTyConidTypeDataConisVanillaDataCondataConUserType dataConSigdataConSrcBangsdataConIsInfixisMarkedStrict HsSrcBangHsUnpackHsStrictHsLazy HsImplBang NoSrcStrict SrcStrictSrcLazy SrcStrictness NoSrcUnpack SrcNoUnpack SrcUnpackSrcUnpackednessNotMarkedStrict MarkedStrictStrictnessMarkhsOverLitNeedsParenshsLitNeedsParens pmPprHsLit pp_st_suffix convertLit overLitTypenegateOverLitValXLit HsDoublePrim HsFloatPrimHsRat HsInteger HsWord64Prim HsInt64Prim HsWordPrim HsIntPrimHsInt HsStringPrimHsString HsCharPrimHsChar ol_witnessol_valol_extXOverLitOverLitol_type ol_rebindable OverLitTc HsIsString HsFractional HsIntegral OverLitValTypesplitForAllTys funResultTyTysPrim alphaTyVarsTyCoRep pprTypeApp pprForAllpprThetaArrowTy pprParendTypeACoAxiomATyConAConLikeAnIdTyContyConClass_maybe isClassTyConsynTyConRhs_maybesynTyConDefn_maybe tyConDataConsisOpenTypeFamilyTyConisTypeFamilyTyConisOpenFamilyTyCon isFamilyTyConisTypeSynonymTyCon isNewTyCon isPrimTyCon tyConTyVars tyConArity tyConKindClass pprFundeps classTvsFds classSCThetaclassATs classMethods dataConTyCondataConFieldLabelspprLExprpprExpr pprSplice pprSpliceDecl pprPatBind pprFunBindHsCmdHsSplice MatchGroupLHsExprHsImpExp pprImpExpreplaceLWrappedNamereplaceWrappedNameieLWrappedName ieWrappedNameieNamesieNamesimpleImportDecl LImportDecl ideclHidingideclAs ideclImplicitideclQualified ideclSafe ideclSource ideclPkgQual ideclNameideclSourceSrcideclExt XImportDecl ImportDeclIEType IEPatternIEName IEWrappedNameLIEWrappedNameLIEXIE IEDocNamedIEDocIEGroupIEModuleContents IEThingAbsIEVarIE IEWildcard NoIEWildcardPatLPat HsExtensionnoExtNoExtGhcPass TypecheckedRenamedParsedPassGhcPsGhcRnGhcTcGhcTcIdIdPLIdP XHsValBindsXEmptyLocalBindsXXHsLocalBindsLRForallXHsLocalBindsLR XValBinds XXValBindsLRForallXValBindsLRXFunBindXPatBindXVarBind XAbsBinds XXHsBindsLRForallXHsBindsLRXABE XXABExportForallXABExportXPSB XXPatSynBindForallXPatSynBindXIPBinds XXHsIPBindsForallXHsIPBindsXCIPBindXXIPBind ForallXIPBindXTypeSig XPatSynSig XClassOpSigXIdSigXFixSig XInlineSigXSpecSig XSpecInstSig XMinimalSig XSCCFunSigXCompleteMatchSigXXSig ForallXSig XXFixitySigForallXFixitySigXTyClDXInstDXDerivDXValDXSigDXDefDXForD XWarningDXAnnDXRuleDXSpliceDXDocD XRoleAnnotDXXHsDecl ForallXHsDecl XCHsGroup XXHsGroupForallXHsGroup XXSpliceDeclForallXSpliceDeclXFamDeclXSynDecl XDataDecl XClassDecl XXTyClDeclForallXTyClDecl XCTyClGroup XXTyClGroupForallXTyClGroupXNoSig XCKindSig XTyVarSigXXFamilyResultSigForallXFamilyResultSig XCFamilyDecl XXFamilyDeclForallXFamilyDecl XCHsDataDefn XXHsDataDefnForallXHsDataDefnXCHsDerivingClauseXXHsDerivingClauseForallXHsDerivingClause XConDeclGADT XConDeclH98 XXConDeclForallXConDeclXCFamEqnXXFamEqn ForallXFamEqn XCClsInstDecl XXClsInstDeclForallXClsInstDecl XClsInstD XDataFamInstD XTyFamInstD XXInstDeclForallXInstDecl XCDerivDecl XXDerivDeclForallXDerivDecl XViaStrategy XCDefaultDecl XXDefaultDeclForallXDefaultDeclXForeignImportXForeignExport XXForeignDeclForallXForeignDecl XCRuleDecls XXRuleDeclsForallXRuleDeclsXHsRule XXRuleDeclForallXRuleDecl XCRuleBndr XRuleBndrSig XXRuleBndrForallXRuleBndr XWarnings XXWarnDeclsForallXWarnDeclsXWarning XXWarnDeclForallXWarnDecl XHsAnnotation XXAnnDeclForallXAnnDeclXCRoleAnnotDeclXXRoleAnnotDeclForallXRoleAnnotDeclXVar XUnboundVar XConLikeOutXRecFld XOverLabelXIPVar XOverLitEXLitEXLamXLamCaseXApp XAppTypeEXOpAppXNegAppXPar XSectionL XSectionRXExplicitTuple XExplicitSumXCaseXIfXMultiIfXLetXDo XExplicitList XRecordCon XRecordUpdXExprWithTySig XArithSeqXSCCXCoreAnn XRnBracketOut XTcBracketOutXSpliceEXProcXStaticXArrAppXArrFormXTickXBinTick XTickPragma XEWildPatXEAsPat XEViewPat XELazyPatXWrapXXExpr ForallXExpr XUnambiguous XAmbiguousXXAmbiguousFieldOccForallXAmbiguousFieldOccXPresentXMissingXXTupArg ForallXTupArg XTypedSpliceXUntypedSplice XQuasiQuoteXSplicedXXSplice ForallXSpliceXExpBrXPatBrXDecBrLXDecBrGXTypBrXVarBrXTExpBr XXBracketForallXBracketXXCmdTop ForallXCmdTopXMG XXMatchGroupForallXMatchGroupXCMatchXXMatch ForallXMatchXCGRHSsXXGRHSs ForallXGRHSsXCGRHSXXGRHS ForallXGRHS XLastStmt XBindStmtXApplicativeStmt XBodyStmtXLetStmtXParStmt XTransStmtXRecStmtXXStmtLR ForallXStmtLR XCmdArrApp XCmdArrFormXCmdAppXCmdLamXCmdParXCmdCaseXCmdIfXCmdLetXCmdDoXCmdWrapXXCmd ForallXCmdXXParStmtBlockForallXParStmtBlockXApplicativeArgOneXApplicativeArgManyXXApplicativeArgForallXApplicativeArgXHsChar XHsCharPrim XHsString XHsStringPrimXHsInt XHsIntPrim XHsWordPrim XHsInt64Prim XHsWord64Prim XHsIntegerXHsRat XHsFloatPrim XHsDoublePrimXXLit ForallXHsLit XXOverLitForallXOverLitXWildPatXVarPatXLazyPatXAsPatXParPatXBangPatXListPat XTuplePatXSumPatXConPatXViewPat XSplicePatXLitPatXNPat XNPlusKPatXSigPatXCoPatXXPat ForallXPatXHsQTvs XXLHsQTyVarsForallXLHsQTyVarsXHsIBXXHsImplicitBndrsForallXHsImplicitBndrsXHsWCXXHsWildCardBndrsForallXHsWildCardBndrs XForAllTyXQualTyXTyVarXAppTyXFunTyXListTyXTupleTyXSumTyXOpTyXParTy XIParamTyXStarTyXKindSig XSpliceTyXDocTyXBangTyXRecTyXExplicitListTyXExplicitTupleTyXTyLit XWildCardTyXXType ForallXType XUserTyVar XKindedTyVar XXTyVarBndrForallXTyVarBndrXXConDeclFieldForallXConDeclField XCFieldOcc XXFieldOccForallXFieldOcc XCImportDecl XXImportDeclForallXImportDeclXIEVar XIEThingAbs XIEThingAll XIEThingWithXIEModuleContentsXIEGroupXIEDoc XIEDocNamedXXIE ForallXIEconvert Convertable ConvertIdX OutputableXOutputableBndrId PlaceHolderplaceHolderNamesTc NameOrRdrNameVar isExportedId isGlobalId isLocalIdTyVarLexerTokenPFailedPOk ParseResult ApiAnnotation unicodeAnngetAndRemoveAnnotationCommentsgetAnnotationCommentsgetAndRemoveAnnotation getAnnotationApiAnns AnnEofPosAnnRarrowtailU AnnRarrowtailAnnLarrowtailU AnnLarrowtailAnnrarrowtailU AnnrarrowtailAnnlarrowtailU AnnlarrowtailAnnWhereAnnViaAnnVbar AnnValStrAnnValAnnUsingAnnUnitAnnTypeAnnTilde AnnThTyQuoteAnnThIdTySplice AnnThIdSpliceAnnThenAnnStock AnnStatic AnnSignatureAnnSimpleQuoteAnnSemiAnnSafeAnnRoleAnnRec AnnRarrowU AnnRarrow AnnQualifiedAnnProc AnnPatternAnnPackageNameAnnOpenS AnnOpenPTE AnnOpenPEAnnOpenP AnnOpenEQU AnnOpenEQAnnOpenEAnnOpenC AnnOpenBUAnnOpenBAnnOpenAnnOfAnnName AnnNewtype AnnModuleAnnMinusAnnMdoAnnLet AnnLarrowU AnnLarrowAnnLam AnnInstanceAnnInfixAnnIn AnnImportAnnIf AnnHiding AnnHeaderAnnGroupAnnFunId AnnForeign AnnForallU AnnForall AnnFamily AnnExportAnnEqualAnnElse AnnDotdotAnnDotAnnDo AnnDeriving AnnDefault AnnDcolonU AnnDcolonAnnData AnnDarrowU AnnDarrow AnnCommaTupleAnnCommaAnnColon AnnCloseS AnnCloseP AnnCloseQU AnnCloseQ AnnCloseC AnnCloseBU AnnCloseBAnnCloseAnnClassAnnCaseAnnBy AnnBackquoteAnnBangAnnAtAnnAs AnnAnyclass AnnKeywordIdAnnBlockCommentAnnLineComment AnnDocOptions AnnDocSectionAnnDocCommentNamedAnnDocCommentPrevAnnDocCommentNextAnnotationCommentRdrNameQualUnqualErrUtilsprettyPrintGhcErrorsHsDocemptyArgDocMapemptyDeclDocMap concatDocs appendDocs ppr_mbDochsDocStringToByteString unpackHDSmkHsDocStringUtf8ByteString mkHsDocString HsDocString LHsDocString DeclDocMap ArgDocMapName nameModuleisExternalName nameSrcSpangetName getOccName NamedThingDynFlagsgoptdefaultObjectTargetOpt_G_NoOptCoercionOpt_G_NoStateHackOpt_PackageTrustOpt_DistrustAllPackagesOpt_BuildDynamicTooOpt_KeepOFilesOpt_KeepHiFilesOpt_KeepLlvmFilesOpt_KeepRawTokenStreamOpt_KeepTmpFilesOpt_KeepSFilesOpt_KeepHcFilesOpt_KeepHiDiffsOpt_ImplicitImportQualifiedOpt_AutoLinkPackagesOpt_SuppressTimestampsOpt_SuppressTicksOpt_SuppressStgFreeVarsOpt_SuppressUniquesOpt_SuppressTypeSignaturesOpt_SuppressUnfoldingsOpt_SuppressIdInfoOpt_SuppressTypeApplicationsOpt_SuppressModulePrefixesOpt_SuppressVarKindsOpt_SuppressCoercionsOpt_HexWordLiteralsOpt_ShowLoadedModulesOpt_ShowMatchesOfHoleFitsOpt_ShowProvOfHoleFitsOpt_ShowTypeOfHoleFitsOpt_ShowTypeAppVarsOfHoleFitsOpt_ShowTypeAppOfHoleFitsOpt_UnclutterValidHoleFitsOpt_AbstractRefHoleFitsOpt_SortBySubsumHoleFitsOpt_SortBySizeHoleFitsOpt_SortValidHoleFitsOpt_ShowValidHoleFitsOpt_ShowHoleConstraintsOpt_PprShowTicksOpt_PprCaseAsLetOpt_DiagnosticsShowCaretOpt_ErrorSpansOpt_SingleLibFolderOpt_WholeArchiveHsLibsOpt_VersionMacrosOpt_OptimalApplicativeDoOpt_ExternalInterpreter Opt_FlatCacheOpt_HpcOpt_RelativeDynlibPaths Opt_RPathOpt_Ticky_Dyn_Thunk Opt_Ticky_LNEOpt_Ticky_Allocd Opt_TickyOpt_SccProfilingOnOpt_ExternalDynamicRefsOpt_PICExecutableOpt_PIEOpt_PICOpt_DeferOutOfScopeVariablesOpt_DeferTypedHolesOpt_DeferTypeErrorsOpt_HelpfulErrorsOpt_NoItOpt_LocalGhciHistoryOpt_GhciLeakCheckOpt_GhciHistoryOpt_GhciSandboxOpt_IgnoreDotGhciOpt_BuildingCabalPackageOpt_SharedImplibOpt_EmbedManifestOpt_GenManifestOpt_PrintBindContentsOpt_PrintEvldWithShowOpt_BreakOnErrorOpt_BreakOnExceptionOpt_HaddockOptions Opt_HaddockOpt_PrintBindResultOpt_HideAllPluginPackagesOpt_HideAllPackages Opt_StgStatsOpt_SplitSections Opt_SplitObjs Opt_NoHsMainOpt_EagerBlackHolingOpt_ExcessPrecisionOpt_IgnoreHpcChangesOpt_IgnoreOptimChangesOpt_ForceRecompOpt_PpOpt_ProfCountEntriesOpt_AutoSccsOnIndividualCafsOpt_WriteInterfaceOpt_ExposeAllUnfoldingsOpt_OmitInterfacePragmasOpt_IgnoreInterfacePragmasOpt_SimplPreInliningOpt_NumConstantFoldingOpt_CatchBottomsOpt_AlignmentSanitisationOpt_SolveConstantDictsOpt_WorkerWrapper Opt_CprAnalOpt_LoopificationOpt_DmdTxDictSelOpt_DictsStrictOpt_FunToThunkOpt_OmitYieldsOpt_AsmShortcuttingOpt_CmmElimCommonBlocks Opt_CmmSinkOpt_IrrefutableTuplesOpt_LlvmFillUndefWithGarbageOpt_LlvmPassVectorsInRegisters Opt_LlvmTBAAOpt_PedanticBottomsOpt_RegsIterative Opt_RegsGraphOpt_EnableRewriteRulesOpt_DictsCheapOpt_UnboxSmallStrictFieldsOpt_UnboxStrictFieldsOpt_CaseFolding Opt_CaseMergeOpt_DoEtaReductionOpt_IgnoreAssertsOpt_DoLambdaEtaExpansionOpt_SpecConstrKeenOpt_SpecConstrOpt_LiberateCase Opt_StgCSEOpt_CSE Opt_StaticArgumentTransformationOpt_CrossModuleSpecialiseOpt_SpecialiseAggressivelyOpt_SpecialiseOpt_LateSpecialise Opt_FloatInOpt_FullLazinessOpt_KillOneShotOpt_KillAbsenceOpt_LateDmdAnalOpt_StrictnessOpt_Exitification Opt_CallArityOpt_PrintTypecheckerElaborationOpt_PrintPotentialInstancesOpt_PrintExpandedSynonymsOpt_PrintUnicodeSyntaxOpt_PrintEqualityRelationsOpt_PrintExplicitRuntimeRepsOpt_PrintExplicitCoercionsOpt_PrintExplicitKindsOpt_PrintExplicitForallsOpt_HideSourcePathsOpt_ShowWarnGroupsOpt_WarnIsError Opt_FastLlvmOpt_NoLlvmManglerOpt_DoAnnotationLintingOpt_DoAsmLintingOpt_DoCmmLintingOpt_DoStgLintingOpt_DoCoreLintingOpt_D_dump_minimal_importsOpt_D_faststring_statsOpt_DumpToFileincludePathsGlobalincludePathsQuoteSf_SafeSf_Trustworthy Sf_UnsafeSf_NoneSafeHaskellModeuniqueIncrement initialUnique maxErrors reverseErrorsmaxInlineMemsetInsnsmaxInlineMemcpyInsnsmaxInlineAllocSizertccInfortldInfoavx512pfavx512favx512eravx512cdavx2avx bmiVersion sseVersionnextWrapperNuminteractivePrintprofAuto colScheme canUseColoruseColor ghciScriptshaddockOptionsghcVersionFileflushErrflushOut log_action ghciHistSize maxWorkerArgsufVeryAggressiveufDearOpufKeenessFactorufDictDiscountufFunAppDiscountufUseThresholdufCreationThresholdextensionFlags extensionstrustworthyOnLocwarnUnsafeOnLoc warnSafeOnLoc pkgTrustOnLocincoherentOnLocoverlapInstLoc newDerivOnLocthOnLoc safeInferred safeInfer safeHaskelllanguagefatalWarningFlags warningFlags generalFlags dumpFlagsgeneratedDumpsnextTempSuffix dirsToClean filesToCleanpkgState pkgDatabase packageEnv trustFlagspluginPackageFlags packageFlagsignorePackageFlagspackageDBFlags depSuffixesdepExcludeModsdepIncludePkgDeps depMakefilehookspluginsfrontendPluginOptspluginModNameOptspluginModNameshpcDirrtsOptsSuggestionsrtsOptsEnabledrtsOptscmdlineFrameworksframeworkPaths libraryPaths includePathsldInputsdumpPrefixForce dumpPrefix dynLibLoaderoutputHi dynOutputFile outputFiledynHiSuf dynObjectSufcanGenerateDynamicToohiSufhcSuf objectSufdumpDirstubDirhiDirdylibInstallName objectDir splitInfobuildTagwaysthisUnitIdInsts_thisComponentId_thisInstalledUnitIdsolverIterationsreductionDepth mainFunIs mainModIs importPaths historySizecmmProcAlignment floatLamArgsliberateCaseThresholdspecConstrRecursivespecConstrCountspecConstrThresholdsimplTickFactormaxUncoveredPatternsrefLevelHoleFitsmaxRefHoleFitsmaxValidHoleFitsmaxRelevantBinds ghcHeapSizeenableTimeStats parMakeCountstrictnessBefore inlineCheck ruleCheckmaxPmCheckIterationsmaxSimplIterations simplPhases debugLeveloptLevel verbosity llvmPasses llvmTargetssettings hscTargetghcLinkghcMode HscNothingHscInterpretedHscLlvmHscAsmHscC HscTargetMkDependOneShot CompManagerGhcMode LinkStaticLib LinkDynLib LinkInMemory LinkBinaryNoLinkGhcLink DriverPhasesPhaseModule pprModulemkModule mkModuleNamemoduleNameString addBootSuffix ml_obj_file ml_hi_file ml_hs_file ModLocation BasicTypesfailed succeeded compareFixity negateFixity defaultFixity maxPrecedenceFixityInfixNInfixRInfixLFixityDirectionInfixPrefix LexicalFixityFailed Succeeded SuccessFlagImplicitSpliceExplicitSpliceSpliceExplicitFlagSevError SevWarningSevInfoSevDumpSevInteractiveSevFatal SevOutputSeveritySrcLoc isSubspanOfspansleftmost_largestleftmost_smallest rightmost cmpLocated eqLocatedaddCLoc combineLocsmkGeneralLocatednoLocunLoc srcSpanEnd srcSpanStart srcSpanEndColsrcSpanStartColsrcSpanEndLinesrcSpanStartLine isGoodSrcSpan mkSrcSpan srcLocSpan noSrcSpan srcLocCol srcLocLine srcLocFilenoSrcLocmkSrcLoc RealSrcLoc UnhelpfulLoc srcSpanFile RealSrcSpan UnhelpfulSpanSrcSpanL GenLocatedLocatedTyThingPredTypeKind ThetaType Outputable alwaysQualifyPrintUnqualified moduleName moduleUnitId ModuleNameUnitId isFunTyCon pprUserLengthpprCols useUnicode GeneralFlagPanicwithSignalHandlersshowGhcExceptionPprProgramError ProgramErrorInstallationErrorPprSorrySorryPprPanic CmdLineError UsageErrorSignal GhcException Exceptiongfinallygbracketgcatch ghci-8.6.3GHCi.RemoteTypes ForeignHValueHValue+haskell-lsp-0.22.0.0-HZCOSgDQYLODVb4z34PcEm Language.Haskell.LSP.DiagnosticsDiagnosticStore1haskell-lsp-types-0.22.0.0-4uvQXZ4RjIwGZdqqtXC5yo%Language.Haskell.LSP.Types.Diagnostic#$sel:_relatedInformation:Diagnostic$sel:_tags: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.UrifromNormalizedFilePathfromNormalizedUritoNormalizedUrigetUriUri NormalizedUriNormalizedFilePathLanguage.Haskell.LSP.Types.ListList#shake-0.19.1-KBzuMqGKNsq1aE028cp8R9%Development.Shake.Internal.Core.RulesactionRules RuleResult%Development.Shake.Internal.Core.TypesAction getProcessID Debouncer registerEventnewAsyncDebouncer noopDebouncerPositionMapping PositionDeltatoDelta fromDeltaPositionResult PositionRange PositionExactunsafeLowerRangeunsafeUpperRange lowerRange upperRangepositionResultToMaybefromCurrentPositiontoCurrentPositiontoCurrentRangefromCurrentRange zeroMappingmkDeltaaddDelta applyChange toCurrent fromCurrent$fMonadPositionResult$fApplicativePositionResult$fEqPositionResult$fOrdPositionResult$fShowPositionResult$fFunctorPositionResult TyVarScopeResolvedScopesUnresolvedScopeScopeNoScope LocalScope ModuleScopeDeclTypeFamDecSynDecDataDecConDec PatSynDecClassDecInstDecBindType RegularBind InstanceBindRecFieldContext RecFieldDeclRecFieldAssign RecFieldMatch RecFieldOccImportImportAs ImportHidingExport ContextInfoUse MatchBindIEThingTyDeclValBind PatternBind ClassTyDeclDecl TyVarBindRecFieldIdentifierDetails identType identInfoNodeIdentifiers IdentifierNodeInfonodeAnnotationsnodeTypenodeIdentifiersHieASTNodenodeInfonodeSpan nodeChildrenHieASTsgetAstsHieArgs HieTypeFixRoll HieTypeFlatHieTypeHTyVarTyHAppTy HTyConApp HForAllTyHFunTyHQualTyHLitTyHCastTy HCoercionTy TypeIndexHieFile hie_hs_file hie_module hie_typeshie_asts hie_exports hie_hs_srcSpan hieVersion HieFileResulthie_file_result_versionhie_file_result_ghc_versionhie_file_result writeHieFile readHieFile HieTypeStateHTStyMaphtyTable freshIndexgenerateReferencesMap renderHieTyperesolveVisibilityfoldTypehieTypeToIface initialHTSfreshTypeIndex compressTypesrecoverFullType getTypeIndexresolveTyVarScopesresolveTyVarScopeLocalgetNameBinding getNameScopegetNameBindingInClassgetNameScopeAndBindinggetScopeFromContextgetBindSiteFromContext flattenAstsmallestContainingSatisfyingselectLargestContainedByselectSmallestContaining definedInAsts isOccurrencescopeContainsSpan combineAst insertAstcombineNodeInfo mergeAstsrightOfleftOf startsRightOf mergeSortAstssimpleNodeInfolocOnlymkScopemkLScope combineScopesmakeNode makeTypeNode mkHieFile HasSrcSpangetLoc HsValBindsValBinds PatSynBindVarPat IEThingAll IEThingWith ClassOpSigTypeSigSigDTyClDInstDValDForDDerivDhPutStringBuffersupportsHieFileshieExportNames ml_hie_file upNameCacheaddIncludePathsQuote setHieDirdontWriteHieFilessetUpTypedHolesgetHeaderImportsaddBootSuffixLocnOut getModuleHash getConArgsgetPackageNamedisableWarningsAsErrorsinitializePluginsapplyPluginsParsedResultAction$fHasSrcSpanGenLocated$fHasSrcSpanName SpanDocUris spanDocUriDoc spanDocUriSrcSpanDoc SpanDocString SpanDocTextshowGhcshowNamelistifyAllSpanslistifyAllSpans'safeTyThingType safeTyThingId emptySpanDocspanDocToMarkdownspanDocToMarkdownForTest$fEqSpanDocUris$fShowSpanDocUris $fEqSpanDoc $fShowSpanDoctoNormalizedFilePath' emptyFilePathuriToFilePath' emptyPathUrifilePathToUri'fromUri noFilePathnoRange showPosition readSrcSpanFileDiagnosticShowDiagnosticShowDiagHideDiag IdeResult ideErrorTextideErrorWithSourceshowDiagnosticsshowDiagnosticsColored$fNFDataShowDiagnostic$fEqShowDiagnostic$fOrdShowDiagnostic$fShowShowDiagnosticEventFileDiagnosticsHscEnvEqhscEnvdepsenvImportPathsmodifyDynFlagslookupPackageConfigtextToStringBuffer runParserstringBufferToByteStringbytestringToStringBuffer prettyPrint printRdrName printName evalGhcEnv runGhcEnvmoduleImportPath newHscEnvEqnewHscEnvEqPreserveImportPathshscEnvWithImportPaths readFileUtf8cgGutsToCoreModulefingerprintToBSfingerprintFromStringBuffer hDuplicateTo'$fBinaryHscEnvEq$fHashableHscEnvEq$fNFDataHscEnvEq $fEqHscEnvEq$fShowHscEnvEq IdentInfonamerenderedparent isDatacon ExportsMap getExportsMapcreateExportsMap$fNFDataIdentInfo$fSemigroupExportsMap $fEqIdentInfo$fGenericIdentInfo$fShowIdentInfo$fHashableIdentInfo$fMonoidExportsMap$fNFDataExportsMap$fShowExportsMapdiagFromErrMsgdiagFromErrMsgssrcSpanToRangerealSrcSpanToRangesrcSpanToFilenamesrcSpanToLocationisInsideSrcSpan toDSeveritydiagFromStringsdiagFromStringnoSpanzeroSpanrealSpancatchSrcErrorsdiagFromGhcExceptionNamedModuleDep nmdFilePath nmdModuleNamenmdModLocationTransitiveDependenciestransitiveModuleDepstransitiveNamedModuleDepstransitivePkgDeps NodeError PartOfCycleFailedToLocateImport ParseErrorParentOfErrorNodeModuleParseErrorDependencyInformation depErrorNodesdepModuleNames depModuleDepsdepReverseModuleDeps depPkgDeps depPathIdMap depBootMapRawDependencyInformation rawImports rawPathIdMap rawBootMap BootIdMap PathIdMap FilePathId getFilePathId ModuleImports moduleImportspackageImportsemptyPathIdMap getPathId insertImportpathToIdlookupPathToIdidToPath insertBootIdreachableModulesprocessDependencyInformationreverseDependenciestransitiveDeps$fNFDataPathIdMap$fShowShowableModuleName$fNFDataModuleParseError$fNFDataLocateError$fNFDataNodeError$fNFDataDependencyInformation$fSemigroupNodeResult$fShowNamedModuleDep$fNFDataNamedModuleDep$fEqNamedModuleDep$fNFDataTransitiveDependencies$fShowFilePathId$fNFDataFilePathId$fEqFilePathId$fOrdFilePathId$fShowModuleImports$fShowPathIdMap$fGenericPathIdMap$fNFDataShowableModuleName$fShowModuleParseError$fGenericModuleParseError$fShowRawDependencyInformation$fEqLocateError$fShowLocateError$fGenericLocateError$fShowNodeError$fGenericNodeError$fShowDependencyInformation$fGenericDependencyInformation$fShowNodeResult$fGenericNamedModuleDep$fEqTransitiveDependencies$fShowTransitiveDependencies$fGenericTransitiveDependenciesLogger logPriorityPriority TelemetryDebugInfoErrorlogError logWarninglogInfologDebug logTelemetry noLogging $fEqPriority$fShowPriority $fOrdPriority$fEnumPriority$fBoundedPriority DelayedActionIdePkgLocationOptionsoptLocateHieFileoptLocateSrcFile IdeTestingIdeDeferIdeReportProgressIdePreprocessedSourcepreprocWarnings preprocErrors preprocSource LspConfig checkParents checkProject CheckParents NeverCheck CheckOnCloseCheckOnSaveAndClose AlwaysCheck CheckProjectshouldCheckProjectOptHaddockParse HaddockParseNoHaddockParse IdeOptionsoptPreprocessor optGhcSessionoptPkgLocationOpts optExtensions optThreads optShakeFilesoptShakeProfiling optTestingoptReportProgressoptLanguageSyntaxoptNewColonConvention optKeywordsoptDeferoptCheckProjectoptCheckParentsoptHaddockParseoptCustomDynFlags IdeGhcSessionloadSessionFunsessionVersiondefaultLspConfigclientSupportsProgressdefaultIdeOptions$fNFDataIdeGhcSession$fShowIdeGhcSession$fEqOptHaddockParse$fOrdOptHaddockParse$fShowOptHaddockParse$fEnumOptHaddockParse$fEqCheckProject$fOrdCheckProject$fShowCheckProject$fFromJSONCheckProject$fToJSONCheckProject$fEqCheckParents$fOrdCheckParents$fShowCheckParents$fGenericCheckParents$fFromJSONCheckParents$fToJSONCheckParents $fEqLspConfig$fOrdLspConfig$fShowLspConfig$fGenericLspConfig$fFromJSONLspConfig$fToJSONLspConfig FileVersion VFSVersionModificationTimeGetModificationTimeGetModificationTime_missingFileDiagnostics OnDiskRulegetHashrunRuleQ FastResultstaleuptoDate IdeAction runIdeActionTIdeState shakeExtrasIdeRuleGlobalIdeOptions IsIdeGlobal ProgressEvent KickStarted KickCompletedWithIndefiniteProgressFuncWithProgressFunc KnownTargets ShakeExtraseventer debouncerloggerglobalsstate diagnosticshiddenDiagnosticspublishedDiagnosticspositionMapping inProgressprogressUpdate ideTestingsession withProgresswithIndefiniteProgressrestartShakeSessionideNcknownTargetsVar exportsMap actionQueue toKnownFilesgetShakeExtrasgetShakeExtrasRules addIdeGlobaladdIdeGlobalExtrasgetIdeGlobalExtrasgetIdeGlobalActiongetIdeGlobalState getIdeOptionsgetIdeOptionsIO deleteValue knownTargets shakeOpen shakeProfile shakeShutmkDelayedAction delayedAction shakeRestart shakeEnqueuegetDiagnosticsgetHiddenDiagnosticsunsafeClearDiagnosticsgarbageCollectdefineuse useWithStale useWithStale_usesWithStale_ runIdeAction mkUpdateruseWithStaleFastuseWithStaleFast' useNoFileuse_ useNoFile_uses_uses usesWithStaledefineEarlyCutoff defineOnDisk needOnDisk needOnDisks setPriority sendEvent ideLogger actionLoggerupdatePositionMapping $fHashableKey$fEqKey $fShowKey$fIsIdeGlobalGlobalIdeOptions $fNFDataValue$fExceptionBadDependency$fShowQ $fBinaryQ $fNFDataA $fShowQDisk $fBinaryQDisk $fNFDataQDisk$fHashableQDisk$fNFDataShakeValue$fBinaryGetModificationTime$fNFDataGetModificationTime$fHashableGetModificationTime$fEqGetModificationTime$fNFDataFileVersion$fFunctorValue$fGenericValue $fShowValue$fMonadReaderIdeAction$fMonadIOIdeAction$fFunctorIdeAction$fApplicativeIdeAction$fMonadIdeAction$fShowBadDependency$fEqQ $fHashableQ $fNFDataQ $fGenericQ$fShowA $fEqQDisk$fGenericQDisk$fGenericShakeValue$fShowShakeValue$fShowGetModificationTime$fGenericGetModificationTime$fShowFileVersion$fGenericFileVersion GetModSummaryGetModSummaryWithoutTimestampsIsFileOfInterest GetModIfaceGetModIfaceFromDiskGhcSessionDeps GhcSessionGenerateByteCode GenerateCore GetSpanInfo TypeCheckGetDependenciesReportImportCyclesGetModuleGraphGetDependencyInformationGetLocatedImportsGetParsedModuleIsFileOfInterestResultNotFOIIsFOIFileOfInterestStatusOnDiskModified HiFileResult hirModSummary hirModIfaceTcModuleResult tmrModule tmrModInfotmrDeferedErrorGetKnownTargets tmrModSummarytmr_hiFileResulthiFileFingerPrint$fBinaryGetKnownTargets$fNFDataGetKnownTargets$fHashableGetKnownTargets$fNFDataTcModuleResult$fShowTcModuleResult$fShowHiFileResult$fNFDataHiFileResult$fBinaryFileOfInterestStatus$fNFDataFileOfInterestStatus$fHashableFileOfInterestStatus$fBinaryIsFileOfInterestResult$fNFDataIsFileOfInterestResult $fHashableIsFileOfInterestResult$fBinaryGetParsedModule$fNFDataGetParsedModule$fHashableGetParsedModule$fBinaryGetLocatedImports$fNFDataGetLocatedImports$fHashableGetLocatedImports $fBinaryGetDependencyInformation $fNFDataGetDependencyInformation"$fHashableGetDependencyInformation$fBinaryGetModuleGraph$fNFDataGetModuleGraph$fHashableGetModuleGraph$fBinaryReportImportCycles$fNFDataReportImportCycles$fHashableReportImportCycles$fBinaryGetDependencies$fNFDataGetDependencies$fHashableGetDependencies$fBinaryTypeCheck$fNFDataTypeCheck$fHashableTypeCheck$fBinaryGetSpanInfo$fNFDataGetSpanInfo$fHashableGetSpanInfo$fBinaryGenerateCore$fNFDataGenerateCore$fHashableGenerateCore$fBinaryGenerateByteCode$fNFDataGenerateByteCode$fHashableGenerateByteCode$fBinaryGhcSession$fNFDataGhcSession$fHashableGhcSession$fBinaryGhcSessionDeps$fNFDataGhcSessionDeps$fHashableGhcSessionDeps$fBinaryGetModIfaceFromDisk$fNFDataGetModIfaceFromDisk$fHashableGetModIfaceFromDisk$fBinaryGetModIface$fNFDataGetModIface$fHashableGetModIface$fBinaryIsFileOfInterest$fNFDataIsFileOfInterest$fHashableIsFileOfInterest&$fBinaryGetModSummaryWithoutTimestamps&$fNFDataGetModSummaryWithoutTimestamps($fHashableGetModSummaryWithoutTimestamps$fBinaryGetModSummary$fNFDataGetModSummary$fHashableGetModSummary$fShowGetKnownTargets$fGenericGetKnownTargets$fEqGetKnownTargets$fOrdGetKnownTargets$fEqFileOfInterestStatus$fShowFileOfInterestStatus$fGenericFileOfInterestStatus$fEqIsFileOfInterestResult$fShowIsFileOfInterestResult$fGenericIsFileOfInterestResult$fEqGetParsedModule$fShowGetParsedModule$fGenericGetParsedModule$fEqGetLocatedImports$fShowGetLocatedImports$fGenericGetLocatedImports$fEqGetDependencyInformation$fShowGetDependencyInformation!$fGenericGetDependencyInformation$fEqGetModuleGraph$fShowGetModuleGraph$fGenericGetModuleGraph$fEqReportImportCycles$fShowReportImportCycles$fGenericReportImportCycles$fEqGetDependencies$fShowGetDependencies$fGenericGetDependencies $fEqTypeCheck$fShowTypeCheck$fGenericTypeCheck$fEqGetSpanInfo$fShowGetSpanInfo$fGenericGetSpanInfo$fEqGenerateCore$fShowGenerateCore$fGenericGenerateCore$fEqGenerateByteCode$fShowGenerateByteCode$fGenericGenerateByteCode$fEqGhcSession$fShowGhcSession$fGenericGhcSession$fEqGhcSessionDeps$fShowGhcSessionDeps$fGenericGhcSessionDeps$fEqGetModIfaceFromDisk$fShowGetModIfaceFromDisk$fGenericGetModIfaceFromDisk$fEqGetModIface$fShowGetModIface$fGenericGetModIface$fEqIsFileOfInterest$fShowIsFileOfInterest$fGenericIsFileOfInterest"$fEqGetModSummaryWithoutTimestamps$$fShowGetModSummaryWithoutTimestamps'$fGenericGetModSummaryWithoutTimestamps$fEqGetModSummary$fShowGetModSummary$fGenericGetModSummaryofInterestRulesgetFilesOfInterestsetFilesOfInterestmodifyFilesOfInterestkick$fIsIdeGlobalOfInterestVar$fBinaryGetFilesOfInterest$fNFDataGetFilesOfInterest$fHashableGetFilesOfInterest$fEqGetFilesOfInterest$fShowGetFilesOfInterest$fGenericGetFilesOfInterest loadSession $fExceptionPackageSetupException$fEqPackageSetupException$fShowPackageSetupExceptionIdeConfiguration&$sel:workspaceFolders:IdeConfigurationregisterIdeConfigurationparseConfigurationparseWorkspaceFoldermodifyWorkspaceFoldersisWorkspaceFile $fIsIdeGlobalIdeConfigurationVar$fShowIdeConfiguration VFSHandlegetVirtualFile makeVFSHandlemakeLSPVFSHandleisFileOfInterestRulemodificationTimegetFileContentsfileStoreRulessetFileModifiedtypecheckParentssetSomethingModified$fIsIdeGlobalVFSHandle$fBinaryGetFileContents$fNFDataGetFileContents$fHashableGetFileContents$fEqGetFileContents$fShowGetFileContents$fGenericGetFileContents getFileExists initialise writeProfileshutdown runActionPartialHandlers WithMessage$sel:withResponse:WithMessage!$sel:withNotification:WithMessage'$sel:withResponseAndRequest:WithMessage$sel:withInitialize:WithMessage$fMonoidPartialHandlers$fSemigroupPartialHandlers$fDefaultPartialHandlers GhcSessionIO toIdeResultuseE useNoFileEusesE defineNoFiledefineEarlyCutOffNoFilegetDependencies getAtPoint getDefinitiongetTypeDefinitiongetParsedModulepriorityTypeCheckpriorityGenerateCorepriorityFilesOfInterest generateCoremainRule$fBinaryGhcSessionIO$fNFDataGhcSessionIO$fHashableGhcSessionIO$fBinaryIsHiFileStable$fNFDataIsHiFileStable$fHashableIsHiFileStable$fEqGhcSessionIO$fShowGhcSessionIO$fGenericGhcSessionIO$fEqIsHiFileStable$fShowIsHiFileStable$fGenericIsHiFileStablerulePackageExportsPlugin pluginRules pluginHandlercodeActionPlugincodeActionPluginWithRulesmakeLspCommandIdgetPid$fMonoidPlugin$fSemigroupPlugin$fDefaultPlugin TestRequest BlockSecondsGetInterfaceFilesDirGetShakeSessionQueueCountplugin$fGenericTestRequest$fFromJSONTestRequest$fToJSONTestRequestgetCompletionsLSP$fBinaryProduceCompletions$fNFDataProduceCompletions$fHashableProduceCompletions$fBinaryLocalCompletions$fNFDataLocalCompletions$fHashableLocalCompletions$fBinaryNonLocalCompletions$fNFDataNonLocalCompletions$fHashableNonLocalCompletions$fEqProduceCompletions$fShowProduceCompletions$fGenericProduceCompletions$fEqLocalCompletions$fShowLocalCompletions$fGenericLocalCompletions$fEqNonLocalCompletions$fShowNonLocalCompletions$fGenericNonLocalCompletionsblockCommandIdtypeSignatureCommandId codeActioncodeLenscommandHandler $fEqExportsAs$fShowNotInScopesetHandlersOutline moduleOutlinegotoDefinitiongotoTypeDefinitionhoversetHandlersDefinitionsetHandlersTypeDefinitionsetHandlersHoverrunLanguageServerasyncRegisterEvent composeDelta FastStringghc-prim GHC.TypesTrue IfaceType IfaceDFunTyHieName toHieName fromHieNamehieMagicbaseGHC.IOFilePathreadHieFileWithVersion NameCache Data.EitherLeft HieHeader ExternalName LocalName KnownKeyName Data.DataDatavalidateScopes DiffIdentDiffppHiesppHieppInfodiffFilediffAstsdiffAstnormalizeIdentsdiffListeqDiffvalidAstHasTypeToHielocTVScopedPScopedRScoped SigContextPatSynFieldContext BindContext IEContext RFContextNoGhcTc listScopes patScopestvScopes$fToHieTScoped6$fHasTypeGenLocatedPSgetGhcVersionPathNamedoCppaddOptP WithDynFlags HasDynFlagsevalWithDynFlagsindexedByPositionStartingFromindexedByPosition unconsRange stripRange GHC.MaybeNothing mergeRanges!extendAllToIncludeCommaIfPossiblePositionIndexedStringPositionIndexed(extendToIncludePreviousNewlineIfPossibleghcVersionCheckerCachedCompletionsallModNamesAsNS unqualCompls qualComplsimportableModules insertText importedFromtypeTextlabelisInfixdocsCC QualCompls getQualComplsCompItemCIcompKind isTypeComplBacktick SurroundedLeftSideslabel_ cliLayout srenderPlainsrenderColored PackageConfig StringBufferCgGutsGHC.Fingerprint.Type Fingerprintbytestring-0.10.8.2Data.ByteString.Internal ByteString dupHandleTo dupHandle_ioe_dupHandlesNotCompatibleSpanInfospaninfoStartLinespaninfoStartColspaninfoEndLinespaninfoEndCol spaninfoTypespaninfoSource spaninfoDocs SpanSourceLitNamedSpanSNoSource SpansInfo spansExprsspansConstraintsgetNameMPackageExportsartifactIsSourcelocateModuleFile mkImportDirs locateModule notFoundErrArtifactsLocationartifactFilePathartifactModLocation FileImport PackageImportisBootLocationmodSummaryToArtifactsLocation NodeResult ErrorNode SuccessNode LocateError FilePathIdSet FilePathIdMapbuildResultGraph withWarnings preprocessorparsePragmasIntoDynFlagsrunLhsrunCpprunPreprocessor actionNameactionPriority getActionpopQueue doneQueue abortQueue ActionQueueDelayedActionInternaluniqueIDnewQueue pushQueue countQueuepeekInProgressJusthaskellKeywordsatPointnameToLocation spansAtPoint ShakeNoCutoff ShakeResultQDiskAdeepseq-1.4.4.0Control.DeepSeqrnf BadDependency ShakeSessionDevelopment.Shake.Database ShakeDatabasecancelShakeSessionKeyValues currentValue lastValueIO lastValue getValuesseqValue withMVar' newSessionsetStageDiagnostics!D:R:RuleResultGetModificationTimeupdateFileDiagnosticsD:R:RuleResultGetParsedModuleD:R:RuleResultGetLocatedImports&D:R:RuleResultGetDependencyInformation D:R:RuleResultReportImportCyclesD:R:RuleResultGetDependenciesD:R:RuleResultTypeCheckD:R:RuleResultGetSpanInfoD:R:RuleResultGenerateCoreD:R:RuleResultGenerateByteCodeD:R:RuleResultGhcSessionD:R:RuleResultGhcSessionDeps!D:R:RuleResultGetModIfaceFromDiskD:R:RuleResultGetModIface,D:R:RuleResultGetModSummaryWithoutTimestampsD:R:RuleResultGetModSummarycomponentDynFlags_componentInternalUnitscomponentTargets componentFP_componentCOptionscomponentDependencyInforawComponentDynFlagsrawComponentTargetsrawComponentFPrawComponentCOptionsrawComponentDependencyInfocradleToOptsAndLibDirnewComponentCache setCacheDircheckDependencyInfogetDependencyInforemoveInplacePackagesmemoIO setOptionscacheDirwrapPackageSetupExceptionPackageSetupException fromTargetIdsetVirtualFileContentsD:R:RuleResultGetFileContentsFileExistsMapVar FileExistsMapgetFileExistsMapUntrackedmodifyFileExistsActionmodifyFileExistsfileExistsRulessetHandlersNotifications RunSimplifiercomputePackageDeps compileModulesetupEnvsetupFinderCacheloadModuleHomeloadDepModuleIOgetImportsParsedgetModSummaryFromBuffergetModSummaryFromImports parseHeaderparseFileContentsremovePackageImports loadInterface getDocsBatch lookupNamegenerateByteCodeaddRelativeImportmkTcModuleResultgenerateAndWriteHieFile writeHiFile loadDepModule loadHieFile docHeaderslookupDocHtmlForModulelookupSrcHtmlForModulegetDocumentationgetDocumentationTryGhcgetDocumentationsTryGhcgetSrcSpanInfos getSpanInfo funBindMapieLNamesgetTypeLHsBindgetConstraintsLHsBindgetTypeLHsExpr getTypeLPat toSpanInfoContext ModuleContext ImportContextImportListContextImportHidingContext ExportContext getCContextlocalCompletionsForParsedModulegetCompletionsstripAutoGeneratedprefixes WithSnippetscacheDataProducerIsHiFileStablegetParsedModuleRulemergeParseErrorsHaddockrawDependencyInformation getHieFilegetPackageHieFiletypeCheckRuleDefinition D:R:RuleResultProduceCompletions ghcExtensionsgetIndentedGroupsBysuggestConstraintsuggestInstanceConstraintsuggestFunctionConstraintremoveRedundantConstraintsextendToWholeLineIfPossible textInRangerangesForBindingaddBindingToImportListmatchRegexUnifySpaces matchRegex unifySpacesdocumentSymbolForImportSummaryrequestMessageResponseAndRequest InitialParamssetHandlersIgnore