Documentation

The result of running a parser.

Newtype wrapper around FilePath that always has normalized slashes. The NormalizedUri and hash of the FilePath are cached to avoided repeated normalisation when we need to compute them (which is a lot).

This is one of the most performance critical parts of ghcide, do not modify it without profiling.

This data type is used to host a FromJSON instance for the encoding used by elisp, where an empty list shows up as "null"

Run an action, usually used for specifying top-level requirements.

main = shake shakeOptions $ do
   action $ do
       b <- doesFileExist "file.src"
       when b $ need ["file.out"]

This action builds file.out, but only if file.src exists. The action will be run in every build execution (unless withoutActions is used), so only cheap operations should be performed. On the flip side, consulting system information (e.g. environment variables) can be done directly as the information will not be cached. All calls to action may be run in parallel, in any order.

For the standard requirement of only needing a fixed list of files in the action, see want.

Define a set of rules. Rules can be created with calls to functions such as %> or action. Rules are combined with either the Monoid instance, or (more commonly) the Monad instance and do notation. To define your own custom types of rule, see Development.Shake.Rule.

The type mapping between the key or a rule and the resulting value. See addBuiltinRule and apply.

The Action monad, use liftIO to raise IO actions into it, and need to execute files. Action values are used by addUserRule and action. The Action monad tracks the dependencies of a rule. To raise an exception call error, fail or liftIO . throwIO.

We 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.

Parser for the GHC output format

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.

Defines 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).

The 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.

An HscEnv with equality. Two values are considered equal if they are created with the same call to newHscEnvEq.

Used to modify dyn flags in preference to calling setSessionDynFlags, since that function also reloads packages (which is very slow).

Given a UnitId try and find the associated PackageConfig in the environment.

Convert from the text package to the GHC StringBuffer. Currently implemented somewhat inefficiently (if it ever comes up in a profile).

Pretty print a GHC value using 'unsafeGlobalDynFlags '.

Pretty print a RdrName wrapping operators in parens

Pretty print a Name wrapping operators in parens

Run a Ghc monad value using an existing HscEnv. Sets up and tears down all the required pieces, but designed to be more efficient than a standard runGhc.

Given 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/Test should be on the include path to find sibling modules.

Wrap an HscEnv into an HscEnvEq.

Wrap an HscEnv into an HscEnvEq.

Unwrap the HscEnv with the original import paths. Used only for locating imports

Read a UTF8 file, with lenient decoding, so it will never raise a decoding error.

Convert from a CgGuts to a CoreModule.

Convert a Fingerprint to a ByteString by copying the byte across. Will produce an 8 byte unreadable ByteString.

Take the Fingerprint of a StringBuffer.

A slightly modified version of hDuplicateTo from GHC. Importantly, it avoids the bug listed in https://gitlab.haskell.org/ghc/ghc/merge_requests/2318.

Produce a GHC-style error from a source span and a message.

Convert a GHC SrcSpan to a DAML compiler Range

Extract a file name from a GHC SrcSpan (use message for unhelpful ones) FIXME This may not be an _absolute_ file name, needs fixing.

Convert a GHC severity to a DAML compiler Severity. Severities below Warning level are dropped (returning Nothing).

Produce a bag of GHC-style errors (ErrorMessages) from the given (optional) locations and message strings.

Produce a GHC-style error from a source span and a message.

Produces an "unhelpful" source span with the given string.

creates a span with zero length in the filename of the argument passed

Catch the errors thrown by GHC (SourceErrors and compiler-internal exceptions like Panic or InstallationError), and turn them into diagnostics

Note 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).

A (maybe) stale result now, and an up to date one later

A Shake database plus persistent store. Can be thought of as storing mappings from (FilePath, k) to RuleResult k.

Define a new Rule without early cutoff

Request a Rule result if available

Request a Rule result, it not available return the last computed result, if any, which may be stale

Request a Rule result, it not available return the last computed result which may be stale. Errors out if none available.

IdeActions 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.

Lookup 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.

Same as useWithStaleFast but lets you wait for an up to date result

Plural version of use

Define a new Rule with early cutoff

Get the vscode client settings stored in the ide state