!q M      !"#$%&'()*+,-./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 L4None"#$%147MPX_k  None"#$%147MPX_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. MghcidevRegister 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"#$%147MPX_k6 NghcideCompose 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_k$ $ghcideScope of a type variable.%This warrants a data type apart from  '6 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  & [foo, bar, baz] Nothing# which later gets resolved into a  %. &ghcide4Unresolved scopes should never show up in the final .hie file ,ghcidetype or data family -ghcide type synonym .ghcidedata declaration /ghcideconstructor declaration 0ghcidepattern synonym 1ghcideclass declaration 2ghcideinstance declaration ;ghcideTypes of imports and exports @ghcide0Different contexts under which identifiers exist Aghcideregular variable Cghcide import/export Eghcide Value binding FghcidePattern 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. Hghcide Declaration Ighcide Type variable Jghcide Record field Kghcide,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) Qghcide'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]). Sghcide=(name of the AST node constructor, name of the AST node Type) Tghcide'The Haskell types of this node, if any. Ughcide%All the identifiers and their details [ghcide*Mapping from filepaths (represented using  O) to the corresponding AST ^ghcidenA list of type arguments along with their respective visibilities (ie. is this an argument that would return  P for isVisibleArgFlag?). `ghcide(Roughly isomorphic to the original core Type. cghcideA flattened version of Type.9See Note [Efficient serialization of redundant type info] ighcidetype with constraint: t1 => t2 (see  Q) nghcideNGHC 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. pghcide Initial Haskell source file path qghcideThe module this HIE file is for rghcideTypes referenced in the  s.9See Note [Efficient serialization of redundant type info] sghcide$Type-annotated abstract syntax trees tghcide"The names that this module exports ughcide'Raw bytes of the initial Haskell source wghcideCurrent version of .hie files &ghcide3names 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 Eghcide,whether or not the binding is in an instanceghcide#scope over which the value is boundghcidespan of entire binding Fghcidescope in the pattern9 (the variable bound can be used further in the pattern)ghcide%rest of the scope outside the patternghcidespan of entire binding Hghcidetype of declarationghcidespan of entire bindingT $ & % ' * ) ( + 2 1 0 / . - , 3 5 4 6 : 9 8 7 ; ? > = < @ J I H G F E D C B A K L N M O P Q R U T S V W Z Y X [ \ ] ^ _ ` a b c l k j i h g f e d m n o u t s r q p v wNone"#$%147MPX_k Rghcide 's get converted into  R's before being written into .hie files. See  S and  T6 for logic on how to convert between these two types. Ughcide1The header for HIE files - Capital ASCII letters HIE. }ghcideWrite a  n to the given  V., with a proper header and symbol tables for  s and  Os WghcideRead a  n from a  V. Can use an existing  XH. Allows you to specify which versions of hieFile to attempt to read.  Y* case returns the failing header versions. ~ghcideRead a  n from a  V. Can use an existing  X. Z x y z { | R [ \ ] U } W ~ SNone"#$%147=?MPX_k 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  T 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  V~'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  S (with  ^)ghcide)return an empty list if this is unhelpful ghcidehelps fill in  S (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. ` a b c d e f g h i j k _!None"#$%.1247=>?HMPVX_kAt lghcideUsed to collect type info mghcideThe main worker class nghcidekdefined so that HsImplicitBndrs and HsWildCardBndrs can know what their implicit bindings are scoping over oghcidezFirst scope remains constant Second scope is used to build up the scope of a tyvar over things to its right, ala RScoped pghcide Pattern scope qghcideScope 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 rghcidecontext for type signatures sghcide#context for pattern synonym fields. tghcidecontext for imports/exports ughcidecontext for imports/exports vghcidecontext for record fields wghcideMarks 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  n% from the outputs of the typechecker. xghcide2Each element scopes over the elements to the right yghcide x specialised to  p things zghcide x specialised to  o things {ghcideDummy instances - never called |ghcide!This instance tries to construct  V 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_gkBO   !"#$%&'()*+,-./0123456789:;<=>?A@EDCBLKJIHGSRQPONMWVUTXYZ`_^]\[abcdeihgfjklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    )('&*10/.-,+7:98;<=>?@ABCDE_^]\[ZYXWVUTSRQPONMLKJIHGFedcba`hgfkijonmlxwvuzy~}|{      *)('&%$#"!+-,10/.;:98765432<=CBA@?>FDEGVUTSRQPONMLKJIHWXYZ[\]`_^adcbefnmlkjihgoyxwvutsrqpz~}|{      !"#$%&'()*+,-./0123456789:;<=>?@ECDBAFGJIHLKMNOPQkjihgfedcba`_^]\[ZYXWVUTSRonmlwvutsrqp}~|{zyx     4 3210/.-,+*)('&%$#"!65987;:@?>=<CBADKIJHGFEONMLPUTSRQYXWV_^]\[Zcab`jihgfedmlkzyxwvutsrqpon}|{~  tsrqp%$#"!65432      $#"!%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      ! l k j i h g p n o m v u t s r q w x y z { |  ~ }   f e d 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/.-,+*)('&%$#" $ % & ' ( ) * + , - . / 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 { | } ~  F x y z { | n o p q r s t u } ~  |   !"#$%&'()*+,-./0123456789:;<=>?A@EDCBLKJIHGSRQPONMWVUTXYZ`_^]\[abcdeihgfjklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    )('&*10/.-,+7:98;<=>?@ABCDE_^]\[ZYXWVUTSRQPONMLKJIHGFedcba`hgfkijonmlxwvuzy~}|{      *)('&%$#"!+-,10/.;:98765432<=CBA@?>FDEGVUTSRQPONMLKJIHWXYZ[\]`_^adcbefnmlkjihgoyxwvutsrqpz~}|{      !"#$%&'()*+,-./0123456789:;<=>?@ECDBAFGJIHLKMNOPQkjihgfedcba`_^]\[ZYXWVUTSRonmlwvutsrqp}~|{zyx     4 3210/.-,+*)('&%$#"!65987;:@?>=<CBADKIJHGFEONMLPUTSRQYXWV_^]\[Zcab`jihgfedmlkzyxwvutsrqpon}|{~  tsrqp%$#"!65432      $#"!%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      ! l k j i h g p n o m v u t s r q w x y z {  ~ }   f e d 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 v w n o u t s r q p m c l k j i h g f e d b ` a ^ _ [ \ ] V W Z Y X Q R U T S P O K L N M @ J I H G F E D C B A ; ? > = < 6 : 9 8 7 3 5 4 + 2 1 0 / . - , ' * ) ( $ & %  "None"#$%147MPX\_`kF ~ghcideFind out path to  ghcversion.h file  #None"#$%147MPX_k ghcide%A monad transformer implementing the   effect $None"#$%147MPX_kx ghcide"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 present ghcide?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"#$%147MPX_kO None"#$%147MPX_k ghcideThe haddock html page ghcide The hyperlinked source html page ghcide#Get ALL source spans in the source.  &None"#$%147MPX_k ghcideEnd result of the completions ghcide6All module names in scope. Prelude is a single module ghcideAll Possible completion items ghcide: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. None"#$%147MPX_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"#$%147MPX_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. ghcideLabel a document. ghcide.The layout options used for the SDK assistant. ghcide%Render without any syntax annotations ghcide Render a Document as an ANSII colored string. ghcide&Rendering width of the pretty printer.    None"#$%147MPX_gk9 ghcidedPattern synonym to make it a bit more convenient to match on diagnostics in things like damlc test.  None"#$%147MPX_k% ghcideAn ] with equality. Two values are considered equal if they are created with the same call to  . 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   in the environment. ghcideConvert from the text package to the GHC  U. 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. ghcide Unwrap an HsEnvEq. ghcideWrap an  into an  . ghcideQRead a UTF8 file, with lenient decoding, so it will never raise a decoding error. ghcideConvert from a   to a `. ghcide Convert a   to a  M by copying the byte across. Will produce an 8 byte unreadable ByteString. ghcide Take the   of a  . 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"#$%147MPX_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. ghcide,End line of the span (absolute), zero-based. ghcide.End column of the span (absolute), zero-based. ghcide-A pretty-printed representation for the type. ghcide The actutal   associated with the span, if any. This can be useful for accessing a variety of information about the identifier such as module, locality, definition location, etc. ghcideDocumentation for the element (None"#$%147HMPVX_k )None"#$%147=?MPX_k None"#$%147MPX_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. ghcideFConvert a GHC severity to a DAML compiler Severity. Severities below Warning' level are dropped (returning Nothing). ghcide#Produce a bag of GHC-style errors ( ErrorMessages=) from the given (optional) locations and message strings. ghcide;Produce a GHC-style error from a source span and a message. ghcide:Produces an "unhelpful" source span with the given string. ghcideFcreates a span with zero length in the filename of the argument passed ghcideRun something in a Ghc monad and catch the errors (SourceErrors and compiler-internal exceptions like Panic or InstallationError). ghcidefile path of span                            *None"#$%147MPX_k& ghcide"True if a module is a source input ghcideElocate a module in the file system. Where we go from *daml to Haskell ghcideThis 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. ghcideelocate a module in either the file system or the package database. Where we go from *daml to Haskell ghcide"Don't call this on a found module.  None"#$%147MPX_kA %ghcideXTransitive module dependencies in topological order. The module itself is not included. &ghcideXTransitive module dependencies in topological order. The module itself is not included. 'ghcide1Transitive pkg dependencies in unspecified order. ghcideA processed node in the dependency graph. If there was any error during processing the node or any of its dependencies, this is an  . Otherwise it is a  . (ghcide4An error attached to a node in the dependency graph. )ghcideThis 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. *ghcide3This module has an import that couldn t be located. ,ghcideThis module is the parent of a module that cannot be processed (either it cannot be parsed, is part of a cycle or the parent of another error node). ghcide%Error when trying to locate a module. -ghcide\This does not contain the actual parse error as that is already reported by GetParsedModule. 1ghcide)Nodes that cannot be processed correctly. 3ghcidebFor a non-error node, this contains the set of module immediate dependencies in the same package. 4ghcideBFor a non-error node, this contains the set of immediate pkg deps. 5ghcideMap from FilePath to FilePathId 6ghcide2Map from hs-boot file to the corresponding hs file 7ghcideBUnprocessed results that we find by following imports recursively. ghcideSet of  >s ghcide Map from  > >ghcideFor 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. AghcideThe imports for a given module. CghcideeImports of a module in the current package and the file path of that module on disk (if we found it) Dghcide8Transitive package dependencies unioned for all imports. ghcideGiven a dependency graph, buildResultGraph detects and propagates errors in that graph as follows: 1. Mark each node that is part of an import cycle as an error node. 2. Mark each node that has a parse error as an error node. 3. Mark each node whose immediate children could not be located as an error. 4. Recursively propagate errors to parents if they are not already error nodes.1   ! " # $ ' % & ( + ) * , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N1 / 0 1 2 3 4 5 6 A B C D 7 8 9 : ; ( + ) * , - . # $ ' % & > ? @   ! " = E F I G H J L M N < K None"#$%147=?HMPVX_k] ghcideMContains the typechecked module and the OrigNameCache entry for that module. ghcide1The parse tree for the file using GetFileContents ghcidewResolve 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 TypeCheck ghcide$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 dependencies ghcidejRead the module interface file from disk. Throws an error for VFS files. This is an internal rule, use  w instead. ghcideUGet a module interface details, either from an interface file or a typechecked module ghcideUGenerate a ModSummary with the timestamps elided, for more successful early cutoff ghcideGenerate a ModSummary that has enough information to be used to get .hi and .hie files. without needing to parse the entire source+ q r s t u v w x y z { | } ~  + q r s t u v w x y z { | } ~  +None"#$%147MPX_ki ghcide Take a GHC monadic action (e.g. typecheckModule pm for some parsed module 'pm@'i) and produce a "decorated" action that will harvest any warnings encountered executing the action. The phase( argument classifies the context (e.g. Parser,  Typechecker).2The ModSummary function is required because of  ghttps://github.com/ghc/ghc/blob/5f1d949ab9e09b8d95319633854b7959df06eb58/compiler/main/GHC.hs#L623-L640 which basically says that log_action is taken from the ModSummary when GHC feels like it. The given argument lets you refresh a ModSummary log_action ,None"#$%147MPX_ko ghcideGiven a file and some contents, apply any necessary preprocessors, e.g. unlit/cpp. Return the resulting buffer and the DynFlags it implies. ghcideDThis reads the pragma information directly from the provided buffer. ghcideERun (unlit) literate haskell preprocessor on a file, or buffer if set ghcideRun CPP on a file ghcideRun a preprocessor on a file  None"#$%147MPSX_kx 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.                  None"#$%147MPSX_k ghcideGThe set of options used to locate files belonging to external packages. ghcidelLocate the HIE file for the given module. The PackageConfig can be used to lookup settings like importDirs. ghcideLocate the source file for the given module. The PackageConfig can be used to lookup settings like importDirs. For DAML, we place them in the package DB. For cabal this could point somewhere in ~.cabal packages. 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 0ghcideokeywords used for completions. These are customizable since DAML has a different set of keywords than Haskell. 1ghcide,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. 4ghcide3Returns the Ghc session and the cradle dependencies 5ghcide9Used as Shake key, versions must be unique and not reused ghcideFrom !https://wiki.haskell.org/Keywords%             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7% # $ % & ' ( ) * + , - . / 0 1   ! "       6     7 2 3 4 5-None"#$%147MPX_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"#$%,147EHMNPSVX_gk- ?ghcide3If false, missing file diagnostics are not reported ghcide5This 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 Hghcide7A (maybe) stale result now, and an up to date one laterghcideName we use for debuggingghcide%Priority with which to log the actionghcide The payload PghcideVA 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. ghcide=Closes the Shake session and returns the pending user actions ghcide'Enqueue an action in the Shake session. ghcideKey typeghcideThe state of the all values. dghcidewThis represents the set of diagnostics that we have published. Due to debouncing not every change might get published. eghcideMap 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. fghcide(How many rules are running for each file gghcide(The generator for unique Lsp identifiers hghcideXWhether to enable additional lsp messages used by the test suite for checking invariants ighcideZUsed in the GhcSession rule to forcefully restart the session after adding a new component jghcideSReport progress about some long running operation (on top of the progress shown by lspShakeProgress) kghcideSame as  j>, but for processes that do not report the percentage completeghcide2Convert 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. xghcide1Delete 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.ghcideSeq the result stored in the Shake value. This only evaluates the value to WHNF not NF. We take care of the latter elsewhere and doing it twice is expensive. yghcideOpen a  P, should be shut using  {.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. }ghcideThese 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 ~ghcideRestart the current   with the given system actions. Any computation running in the current session will be aborted, but user actions (added via  G) will be requeued. Progress is reported only on the system actions. ghcide"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  S with a set of initial system and user actions Will crash if there is an existing  c running. Progress is reported only on the system actions. Only user actions will get re-enqueued ghcide[FIXME: This function is temporary! Only required because the files of interest doesn't work ghcideFClear the results for all files that do not match the given predicate. ghcideIdeActions 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. ghcideLookup 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 ghcide6Return up2date results. Stale results will be ignored. ghcide5Return the last computed result which might be stale.ghcideySets the diagnostics for a file and compilation step if you want to clear the diagnostics call this with an empty listghcide$Get the modification time of a file. <ghcide8Large unit (platform dependent, do not make assumptions)ghcide8Small unit (platform dependent, do not make assumptions) yghcidediagnostic handlerghcidecurrent resultsghcideGthe time that the file these diagnostics originate from was last editedc : ; < = n > ? @ 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 j k b i ] ^ _ ` c d e f g h l m o p q r s t u v w x y z { | } ~  d P Q [ \ a j k b i ] ^ _ ` c d e f g h l m o p R = n > ? n y { ~  z } H I J K U q r u t s v w S T : ; < @ A x B C D E Z Y V W X O | L M N F GNone"#$%147=?HMPVX_kW ghcide6The rule that initialises the files of interest state. ghcide'Get the files that are open in the IDE. ghcidexSet the files-of-interest - not usually necessary or advisable. The LSP client will keep this information up to date. ghcide{Modify the files-of-interest - not usually necessary or advisable. The LSP client will keep this information up to date. ghcide9Typecheck all the files of interest. Could be improved  None"#$%147HMPVX_k/-ghcide|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 component"ghcide-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]. ghcide'Given a root directory, return a Shake $ which setups an  22 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 directory&ghcideConvert a target to a list of potential absolute paths. A TargetModule can be anywhere listed by the supplied include directories A target file is a relative path but with a specific prefix so just need to canonicalise it.'ghcide,Create a mapping from FilePaths to HscEnvEqs(ghcideSet 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 unsatisfiable.ghcide Sub directory for the cache path/ghcideWrap any exception as a 0  None"#$%147MPX_dk0 ghcide)Lsp client relevant configuration details  None"#$%147HMPVX_kCF ghcidehaskell-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  ) we abstract over the VFS implementation. ghcide"get the contents of a virtual file1ghcide~set a specific file to a value. If Nothing then we are ignoring these signals anyway so can just say something was modified ghcidelReturns the modification time and the contents. For VFS paths, the modification time is the current time. ghcideMNotify the compiler service that a particular file has been modified. Use  ` to say the file is no longer in the virtual file system but should be sourced from disk, or   to give its new value. ghcideWNote that some buffer for a specific file has been modified but not with what changes. ghcideNote 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.2ghcidefGet the contents of a file, either dirty (if the buffer is modified) or Nothing to mean use from disk. .None "#$%147HMPVX_kT93ghcideA wrapper around a mutable 44ghcide%A map for tracking the file existence5ghcide!Grab the current global value of 4 without acquiring a dependency6ghcide&Modify the global store of file exists7ghcide&Modify the global store of file exists8ghcideReturns 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.9ghcide Installs the 8 rules. Provides a fast implementation if client supports dynamic watched files. Creates a global state as a side effect in that case.789None"#$%147=?HMPSVX_kVh ghcide Initialise the Compiler Service. ghcideShutdown the Compiler Service. P v w v w P None"#$%147MPSX_dkW~  /None"#$%147MPSX_dkX|:0None"#$%147MPSX_kg;ghcide>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 #256<ghcideGGiven a string buffer, return the string (after preprocessing) and the L.=ghcide;Given a package identifier, what packages does it depend on>ghcide*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.AghcideLoad 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.BghcideLoad module interface.CghcideuGhcMonad function to chase imports of a module given as a StringBuffer. Returns given module's name and its imports.Dghcide-Produce a module summary from a StringBuffer.EghcidexGiven a buffer, env and filepath, produce a module summary by parsing only the imports. Runs preprocessors as needed.FghcideParse only the module headerGghcideGiven a buffer, flags, and file path, produce a parsed module (or errors) and any parse warnings. Does not run any preprocessorsHghcideAfter parsing the module remove all package imports referring to these packages as we have already dealt with what they map to.IghcidegRetuns an up-to-date module interface, regenerating if needed. Assumes file exists. Requires the  to be set up with dependenciesJghcide"Non-interactive, batch version of 12<. The interactive paths create problems in ghc-lib buildsKghcide"Non-interactive, batch version of 13<. The interactive paths create problems in ghc-lib buildsFghcide flags to useghcide#the filename (for source locations)ghcide6Haskell module source text (full Unicode is supported)Gghcide flags to useghcideThe package imports to ignoreghcide#the filename (for source locations)ghcidethe modification timestampghcide6Haskell module source text (full Unicode is supported)Ighcide!Action to regenerate an interfaceJghcide%a moudle where the names are in scopeKghcide%A module where the Names are in scope ;L<=M>NOPQR@ASEFTIJK4None"#$%147MPSX_kUghcide$Shows this part of the documentationVghcideGiven 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.htmlWghcide,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.htmlXghcide3All of the possible modules it could be defined in.ghcide$The name you want documentation for.YZX5None"#$%147MPSX_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 IdP_ghcide#Get the name and type of a binding.`ghcide!Get information about constraintsaghcide'Get the name and type of an expression.bghcide#Get the name and type of a pattern.cghcidePretty print the types into a  .[ghcide!Dependencies in topological orderghcide%Dependencies parsed, optional if the  already contains docs\ghcideimports[6None"#$%147MPX_k dghcideA 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 completioneghcidemodule context with module namefghcideimport context with module namegghcide$import list context with module namehghcide&import hiding context with module nameighcide4List of exported identifiers from the current modulejghcideGenerates 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 declskghcideAProduces completions from the top level declarations of a module.lghcideAReturns the cached completions for the given module and position.mghcidejUnder certain circumstance GHC generates some extra stuff that we don't want in the autocompleted symbolsnghcide(Prefixes that can occur in a GHC OccName opqklNone"#$%147=?HMPVX_dk rghcideRGiven 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.sghcideGiven 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.tghcideaGiven a target file path, construct the raw dependency results by following imports recursively. ghcide)A rule that wires per-file rules togetherughcidefile we're editingghcidemodule dep we want info forghcidehie stuff for the modulevghcide$Package Module to load .hie file forghcide0Path of home module importing the package modulewghcide$Should generate .hi and .hie files ? # $ ' % & @ A P             P # $ ' % & @ A            7None"#$%147MPX_k None"#$%147MPX_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"#$%147HMPVX_k1xghcideGenerate code actions.yghcide#Produce completions info for a file + +None"#$%147MPX_dkޱ ?ghcideGenerate code actions. @ghcideGenerate code lenses. Aghcide(Execute the "typesignature.add" command.zghcideAll the GHC extensions{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@Returns Just (the submatches) for the first capture, or Nothing.  > ? @ A > ? @  ANone"#$%147MPX_dk1ghcideWrap 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. D E D ENone"#$%147MPX_kghcide6Respond to and log a hover or go-to-definition request F G H I J K K I J H F GNone"#$%147EMPSX_kghcideA 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. L L89:89;89<89=89>89?89@89A89B89C89D89E89F89G89H89I89J89K89L89M89N89O89P89Q89R89S89T89U89V89W89X89Y89Z89[89\89]89^89_89`89a89b89c89d89e89f89g89h89i89j89k89l89m89n89o89p89q89r89s89t89u89v89w89x89y89z89{89|89}89~89898989898989898989898989898989898989898989898989898989898888888881818181818181818181818128181818181818181818181818181818181818181818181818181818888888888888888888888888888888888888888888888888888888888888888 8 8 8 8 88888888888888888888 8!8!8"#8"$8"%8"&8"'8"(8")8")8*+8*,8*-8*.8*/8*08*18*28*38*48*58*68*78*88*98*:8*;8*<8*=8*>8*?8*@8*A8*B8*C8*D8*E8*F8*G8*H8*I8*J8*K8*L8*M8*N8*O8*P8*Q8*R8*S8*T8*U8*V8*W8*X8*Y8*Z8*[8*\8*]8*^8*_8*`8*a8*b8*c8*d8*e8*f8*g8*h8*i8*j8*k8*l8*m8*n8*o8*p8*q8*r8*s8*t8*u8*v8*w8*x8*y8*z8*{8*|8*}8*~8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*8*88888888888888888888888888888888888888888888888888888888888888888888888888888888888 8 8 8 8 8888888888888888888 8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/80818283848586878788898:8;8<8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8S8T8T8U8V8W8X8Y8Z8[8\8]8]8^8_8`8a8b8c8d8d8e8f8g8h8i8j8k8l8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888 8 8 8 8 88888888888888888888 8!8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8<8=8>8?8@8A8B8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8R8S8T8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8a8b8c8d8e8f8g8h8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}8~88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888 8 8 8 8 8888888888888888888 8!8"8#8$8$8%8&8'8(8(8)8*8+8,8-8.8/808,8182382482582682782882982:82;82<82=82>82?82@82A82B82C82D82E82F82G82H82I82J82K82L82M82N82O82P82Q82R82S82T82U82V82W82X82Y82Z82[82\82]82^82_82]82`82a82b82c82d82e82f82g82h82i82j82k82l82m82n82o82p82q82r82s82t82u82v82w82x82y82z82{82|82}82~828282828282828282828282828282828282828282828282828282\82828282828282828282828282828282828282828282828282828282828282828282828888888888888888888888888888888888888888888888888888888888888888888888888888888 8 8 8 8 888888888888888888888 8!8"8#8$8%8&8'8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K838L8M8N8O8P8Q8R8S8T8T8U8V8W8X8Y8Z8[8[8\8]8^8_8`8a8b8c8d8d8e8f8g8h8ij8ik8il8im8in8in8io8ip8iq8ip8ir8is8it8iu8iv8iw8ix8iy8iz8i{8i|8i}8i~8i8i8i8i8i8i8i8i8i8i8i8i8i88888888888888888888888888888888888-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8-8--8-8-8-8-8-8-.8-8-8-8-8-8-8-8-8888888888888888888888888888888888888888888888i888888888888 8 8 8 8 88888888888888888888 8!8"8#8$8#8%8&8'(8')8')8'*8'+8',8'-8'.8'/8'08'18'28'38'48'58'8'68'78'88'98':8';8'<8'=8'>8'?8'8'@8'A8'B8'C8'D8'E8'F8'G8'H8'I8'J8'K8'L8'M8'N8'O8'P8'Q8'R8'S8'T8'U8'V8'W8'X8'Y8'Z8'8'[8'\8']8'^8'_8'`8'a8'b8'c8'd8'e8'f8'g8'h8'i8'j8'k8'l8'm8'n8' 8'o8'p8'q8'r8's8't8'u8'v8'w8'x8'y8'z8'{8'|8'}8'~8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'R8'8'8'8'8'8'8'8'8'8'8' 8' 8' 8' 8' 8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8'8' 8'!8'"8'8'#8'$8'%8'&8''8'(8')8'*8'+8',8'-8'.8'/8'08'18'28'38'48'58'68'78'8'88'98':8';8'<8'=8'>8'?8'@8'A8'B8'C8'D8'E8'F8'G8'H8'I8'J8'K8'L8'M8'N8'O8'P8'Q8'R8'S8'T8'U8'V8'W8'X8'Y8'Z8'[8'\8']8'^8'_8'`8'a8'b8'c8'd8'e8'f8'g8'h8'i8'j8'k8'l8'm8'n8'o8'p8'Z8'q8'r8's8't8'u8'v8'w8'x8'y8'z8'{8'|8'}8'~8'8'8'8'8'8'8'8'8'8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888 8 8  8  8  888888888888888888 8!8"8#8$8%&8%'8%(8%)8%*8%+8%,8%-8%.8%/8%08%18%28%38%48%58%68%78%88%98%:8%;8%<8%=8%>8%?8%@8%A8%B8%C8%D8%E8%F8%G8%H8%I8%J8%K8%L8%M8%N8%O8%P8%Q8%R8%S8%T8%U8%V8%W8%X8%Y8%Z8%[8%\8%]8%^8%_8%`8%a8%b8%c8%d8%e8%f8%g8%h8%i8%j8%k8%l8%m8%n8%o8%p8%q8%r8%s8%t8%u8%v8%w8%x8%y8%z8%{8%|8%}8%~8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8%8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% 8% !8% "8% #8% $8% %8% &8% '8% (8% )8% *8% +8% ,8% -8% .8% /8% 08% 18% 28% 38% 48% 58% 68% 78% 88% 98% :8% ;8% <8% =8% >8% ?8% @8% A8% B8% C8% D8% E8% F8% G8% H8% I8% J8% K8% L8% M8% N8% O8% P8% Q8% R8% S8% T8% U8% V8% W8% X8% Y8% Z8% [8% \8% ]8% ^8% _8% `8% a8% b8% c8% d8% e8% f8% g8% h8% i8% j8% k8%%8% l8% m8% n8% o8% p8% q8% r8% s8% t8% u8% v8% w8% x8% y8% z8% {8 | }8 ~ 8 ~ 8 ~ 8 ~ 8 ~ 8 ~ 8 ~ 8 ~ 8 ~ 8 8 8 8 8 8 8  8  8  8  8  8  8  8  8  8  8  8  8  8  8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8  8  8  8  8 8  8  8  8  8  8  8  88 8 8 8 8 8  8 ~ 8 ~ 8 ~ ~8 ~ 8 ~ 8 88% 8% 8% 8%%8% 8 8 8  8  8  8  8  8  8  8  8  8  8  88 8 8                                                            ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N N O P Q R S S T U V W X Y Z [ \ \ ] ^ ^ _ ` a b c d e f g h i j k l m m n o p q r s t u v v w x y z { | } ~                                          !                                                                                                                             !  "  #  $  %  &  &  '  ' ( ) * + , -  .  . / 0 1  2  3  4  4 5  6  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  f  g  g  h  h  i  i  j  j  k  k  l  l  m  m  n  n  o  o  p  p  q  q  r  r  s  s  t  t  u  u v w  x  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 { | } ~                                                                                                                7                                                8     8     ! " # $ % &8 ' ' # ( ) * + , - # . / 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# R8% S# T$ U$ V$ W$ X # Y Z$ [$ \$ ]$ ^% _& `& a& b& c& d& e& f& g& h& i& j& k& l& l& m& n& o& p& q& r& s& t u v w x8 y y8 z z8 { # | } ~     ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' ( ( ( ( ( ( ( ( ( ( * * * * * * * * * * ?* * * *                      + , , , , , # Y  - - - - -                                                   ......./ 0 0e0 0 0 0000000000000 0d0000000 4!4"4#4$4%4&5'5(5)5*5+5,5-5.5/606162636465666768696:6;6;6<=>?@ABCDEFGHIJKLMNOPQRSTU#ghcide-0.3.0-Dfp4umcHt6s1wVYFQXPyfqDevelopment.IDE.GHC.CompatDevelopment.IDE.GHC.Util!Development.IDE.Types.DiagnosticsDevelopment.IDE.Types.LocationDevelopment.IDE.CompatDevelopment.IDE.Core.Debouncer$Development.IDE.Core.PositionMappingDevelopment.IDE.Spans.CommonDevelopment.IDE.LSP.ProtocolDevelopment.IDE.GHC.Error,Development.IDE.Import.DependencyInformationDevelopment.IDE.Core.RuleTypesDevelopment.IDE.Types.LoggerDevelopment.IDE.Types.OptionsDevelopment.IDE.Core.ShakeDevelopment.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.Plugin"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.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 HsIPBinds HsValBindsHsLocalBindsLRLHsLocalBindsLR XValBindsLRValBinds 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 getProcessID Debouncer registerEventnewAsyncDebouncer noopDebouncerPositionMapping PositionDeltatoDelta fromDeltafromCurrentPositiontoCurrentPositiontoCurrentRangefromCurrentRange zeroMappingmkDeltaaddDelta applyChange toCurrent fromCurrent 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 PatSynBindVarPat IEThingAll IEThingWith ClassOpSigTypeSigSigDTyClDInstDValDForDDerivDhPutStringBuffersupportsHieFileshieExportNames ml_hie_file upNameCacheaddIncludePathsQuote setHieDirdontWriteHieFilesgetHeaderImports getModuleHash getConArgsgetPackageName$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$fShowShowDiagnosticEventFileDiagnosticsHscEnvEqmodifyDynFlagslookupPackageConfigtextToStringBuffer runParserstringBufferToByteStringbytestringToStringBuffer prettyPrint printRdrName printName evalGhcEnv runGhcEnvmoduleImportPathhscEnvdeps newHscEnvEq readFileUtf8cgGutsToCoreModulefingerprintToBSfingerprintFromStringBuffer hDuplicateTo'$fBinaryHscEnvEq$fHashableHscEnvEq$fNFDataHscEnvEq $fEqHscEnvEq$fShowHscEnvEqdiagFromErrMsgdiagFromErrMsgssrcSpanToRangesrcSpanToFilenamesrcSpanToLocationisInsideSrcSpan toDSeveritydiagFromStringsdiagFromStringnoSpanzeroSpanrealSpancatchSrcErrorsdiagFromGhcExceptionNamedModuleDep nmdFilePath nmdModuleNamenmdModLocationTransitiveDependenciestransitiveModuleDepstransitiveNamedModuleDepstransitivePkgDeps NodeError PartOfCycleFailedToLocateImport ParseErrorParentOfErrorNodeModuleParseErrorDependencyInformation depErrorNodesdepModuleNames depModuleDeps depPkgDeps depPathIdMap depBootMapRawDependencyInformation rawImports rawPathIdMap rawBootMap BootIdMap PathIdMap FilePathId getFilePathId ModuleImports moduleImportspackageImportsemptyPathIdMap getPathId insertImportpathToIdlookupPathToIdidToPath insertBootIdreachableModulesprocessDependencyInformationtransitiveDeps$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$fGenericTransitiveDependencies GetModSummaryGetModSummaryWithoutTimestampsIsFileOfInterest GetModIfaceGetModIfaceFromDiskGhcSessionDeps GhcSessionGenerateByteCode GenerateCore GetSpanInfo TypeCheckGetDependenciesReportImportCyclesGetDependencyInformationGetLocatedImportsGetParsedModule HiFileResult hirModSummary hirModIfaceTcModuleResult tmrModule tmrModInfo tmrModSummarytmr_hiFileResulthiFileFingerPrint$fNFDataTcModuleResult$fShowTcModuleResult$fShowHiFileResult$fNFDataHiFileResult$fBinaryGetParsedModule$fNFDataGetParsedModule$fHashableGetParsedModule$fBinaryGetLocatedImports$fNFDataGetLocatedImports$fHashableGetLocatedImports $fBinaryGetDependencyInformation $fNFDataGetDependencyInformation"$fHashableGetDependencyInformation$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$fEqGetParsedModule$fShowGetParsedModule$fGenericGetParsedModule$fEqGetLocatedImports$fShowGetLocatedImports$fGenericGetLocatedImports$fEqGetDependencyInformation$fShowGetDependencyInformation!$fGenericGetDependencyInformation$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$fGenericGetModSummaryLogger logPriorityPriority TelemetryDebugInfoErrorlogError logWarninglogInfologDebug logTelemetry noLogging $fEqPriority$fShowPriority $fOrdPriority$fEnumPriority$fBoundedPriorityIdePkgLocationOptionsoptLocateHieFileoptLocateSrcFile IdeTestingIdeDeferIdeReportProgressIdePreprocessedSourcepreprocWarnings preprocErrors preprocSource IdeOptionsoptPreprocessor optGhcSessionoptPkgLocationOpts optExtensions optThreads optShakeFilesoptShakeProfiling optTestingoptReportProgressoptLanguageSyntaxoptNewColonConvention optKeywordsoptDefer IdeGhcSessionloadSessionFunsessionVersionclientSupportsProgressdefaultIdeOptions$fNFDataIdeGhcSession$fShowIdeGhcSession FileVersion VFSVersionModificationTimeGetModificationTimeGetModificationTime_missingFileDiagnostics OnDiskRulegetHashrunRuleQ FastResultstaleuptoDate IdeAction runIdeActionT DelayedActionIdeState shakeExtrasIdeRuleGlobalIdeOptions IsIdeGlobal ProgressEvent KickStarted KickCompletedWithIndefiniteProgressFuncWithProgressFunc ShakeExtraseventer debouncerloggerglobalsstate diagnosticshiddenDiagnosticspublishedDiagnosticspositionMapping inProgressprogressUpdate ideTestingsession withProgresswithIndefiniteProgressrestartShakeSessionideNcgetShakeExtrasgetShakeExtrasRules addIdeGlobaladdIdeGlobalExtrasgetIdeGlobalExtrasgetIdeGlobalActiongetIdeGlobalState getIdeOptionsgetIdeOptionsIO deleteValue 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$fShowDelayedAction$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$fGenericFileVersionofInterestRulesgetFilesOfInterestsetFilesOfInterestmodifyFilesOfInterestkick$fIsIdeGlobalOfInterestVar$fBinaryGetFilesOfInterest$fNFDataGetFilesOfInterest$fHashableGetFilesOfInterest$fEqGetFilesOfInterest$fShowGetFilesOfInterest$fGenericGetFilesOfInterest loadSession $fExceptionPackageSetupException$fEqPackageSetupException$fShowPackageSetupExceptionIdeConfiguration&$sel:workspaceFolders:IdeConfigurationregisterIdeConfigurationparseConfigurationparseWorkspaceFoldermodifyWorkspaceFoldersisWorkspaceFile $fIsIdeGlobalIdeConfigurationVar$fShowIdeConfiguration VFSHandlegetVirtualFile makeVFSHandlemakeLSPVFSHandlemodificationTimegetFileContentsfileStoreRulessetBufferModifiedsetFileModifiedsetSomethingModified$fIsIdeGlobalVFSHandle$fBinaryGetFileContents$fNFDataGetFileContents$fHashableGetFileContents$fEqGetFileContents$fShowGetFileContents$fGenericGetFileContents 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$fShowGenerateInterfaceFiles$fEqGhcSessionIO$fShowGhcSessionIO$fGenericGhcSessionIO$fEqIsHiFileStable$fShowIsHiFileStable$fGenericIsHiFileStablerulePackageExportsPlugin pluginRules pluginHandlercodeActionPlugincodeActionPluginWithRulesmakeLspCommandIdgetPid$fMonoidPlugin$fSemigroupPlugin$fDefaultPluginplugin$fBinaryProduceCompletions$fNFDataProduceCompletions$fHashableProduceCompletions$fBinaryLocalCompletions$fNFDataLocalCompletions$fHashableLocalCompletions$fBinaryNonLocalCompletions$fNFDataNonLocalCompletions$fHashableNonLocalCompletions$fEqProduceCompletions$fShowProduceCompletions$fGenericProduceCompletions$fEqLocalCompletions$fShowLocalCompletions$fGenericLocalCompletions$fEqNonLocalCompletions$fShowNonLocalCompletions$fGenericNonLocalCompletions codeActioncodeLensexecuteAddSignatureCommand $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!extendAllToIncludeCommaIfPossiblePositionIndexedStringPositionIndexedghcVersionCheckerCachedCompletionsallModNamesAsNS 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 spansExprsspansConstraintsgetNameMPackageExportsPackageExportsMap IdentInforenderednameparent isDatacon mkIdentInfosartifactIsSourcelocateModuleFile mkImportDirs locateModule notFoundErrArtifactsLocationartifactFilePathartifactModLocation FileImport PackageImportisBootLocationmodSummaryToArtifactsLocation NodeResult ErrorNode SuccessNode LocateError FilePathIdSet FilePathIdMapbuildResultGraphD: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:RuleResultGetModSummary withWarnings preprocessorparsePragmasIntoDynFlagsrunLhsrunCpprunPreprocessorJusthaskellKeywordsatPointnameToLocation spansAtPoint ShakeNoCutoff ShakeResultQDiskAdeepseq-1.4.4.0Control.DeepSeqrnf BadDependency actionNameactionPriority getAction ShakeSession#shake-0.19.1-3gb0AZMulvxF7nPOeqPqW3Development.Shake.Database ShakeDatabasecancelShakeSessionrunInShakeSessionKeyValues currentValue lastValueIO lastValue getValuesseqValue withMVar' newSessionsetStageDiagnostics!D:R:RuleResultGetModificationTimeupdateFileDiagnosticscomponentDynFlags_componentInternalUnitscomponentTargets componentFP_componentCOptionscomponentDependencyInforawComponentDynFlagsrawComponentTargetsrawComponentFPrawComponentCOptionsrawComponentDependencyInfo%Development.Shake.Internal.Core.TypesActioncradleToOptsAndLibDir targetToFilenewComponentCache setCacheDircheckDependencyInfogetDependencyInforemoveInplacePackagesmemoIO setOptionscacheDirwrapPackageSetupExceptionPackageSetupExceptionsetVirtualFileContentsD:R:RuleResultGetFileContentsFileExistsMapVar FileExistsMapgetFileExistsMapUntrackedmodifyFileExistsActionmodifyFileExists getFileExistsfileExistsRulessetHandlersNotifications RunSimplifiercomputePackageDeps compileModulesetupEnvsetupFinderCacheloadModuleHomeloadDepModuleIOgetImportsParsedgetModSummaryFromBuffergetModSummaryFromImports parseHeaderparseFileContentsremovePackageImports loadInterface getDocsBatch lookupNamegenerateByteCodeaddRelativeImportmkTcModuleResultgenerateAndWriteHieFilegenerateAndWriteHiFile loadDepModule loadHieFile docHeaderslookupDocHtmlForModulelookupSrcHtmlForModulegetDocumentationgetDocumentationTryGhcgetDocumentationsTryGhcgetSrcSpanInfos getSpanInfo funBindMapieLNamesgetTypeLHsBindgetConstraintsLHsBindgetTypeLHsExpr getTypeLPat toSpanInfoContext ModuleContext ImportContextImportListContextImportHidingContext ExportContext getCContextlocalCompletionsForParsedModulegetCompletionsstripAutoGeneratedprefixes WithSnippetscacheDataProducerIsHiFileStablemergeParseErrorsHaddockrawDependencyInformation getHieFilegetPackageHieFiletypeCheckRuleDefinitiongetCompletionsLSP D:R:RuleResultProduceCompletions ghcExtensionssuggestConstraintsuggestInstanceConstraintsuggestFunctionConstraintremoveRedundantConstraintsextendToWholeLineIfPossible textInRangerangesForBindingaddBindingToImportList matchRegexdocumentSymbolForImportSummaryrequestMessageResponseAndRequest InitialParamssetHandlersIgnore