apply-refact-0.14.0.0: Perform refactorings specified by the refact library.

Safe Haskell | None
Language | Haskell2010

Refact.Apply

Synopsis

- applyRefactorings :: FilePath -> Maybe (Int, Int) -> [[Refactoring SrcSpan]] -> FilePath -> [String] -> IO String
- applyRefactorings' :: Maybe (Int, Int) -> [[Refactoring SrcSpan]] -> Module -> IO String
- runRefactoring :: Data a => a -> Refactoring SrcSpan -> StateT Int IO a
- parseExtensions :: [String] -> ([Extension], [Extension], [String])

# Documentation

applyRefactorings #

Arguments

:: FilePath | FilePath to GHC's libdir. It is possible to use `libdir` from ghc-paths package, but note this will make it difficult to provide a binary distribution of your program.
-> Maybe (Int, Int) | Apply hints relevant to a specific position

-> [[Refactoring SrcSpan]]

`Refactoring`s to apply. Each inner list corresponds to an HLint Idea. An `Idea` may have more than one `Refactoring`.

The `Idea`s are sorted in ascending order of starting location, and are applied in that order. If two `Idea`s start at the same location, the one with the larger source span comes first. An `Idea` is filtered out (ignored) if there is an `Idea` prior to it which has an overlapping source span and is not filtered out.

-> FilePath | Target file
-> [String] | GHC extensions, e.g., `LambdaCase`, `NoStarIsType`. The list is processed from left to right. An extension (e.g., `StarIsType`) may be overridden later (e.g., by `NoStarIsType`). These are in addition to the `LANGUAGE` pragmas in the target file. When they conflict with the `LANGUAGE` pragmas, pragmas win.
-> IO String |

Apply a set of refactorings as supplied by HLint

applyRefactorings' #

Arguments

:: Maybe (Int, Int) |
-> [[Refactoring SrcSpan]] |
-> Module | ghc-exactprint AST annotations. This can be obtained from `postParseTransform`. Anns -> | Parsed module
-> IO String |

Like `applyRefactorings`, but takes a parsed module rather than a file path to parse.

runRefactoring :: Data a => a -> Refactoring SrcSpan -> StateT Int IO a #

Peform a `Refactoring`.

parseExtensions :: [String] -> ([Extension], [Extension], [String]) #

Parse the input into (enabled extensions, disabled extensions, invalid input). Implied extensions are automatically added. For example, `FunctionalDependencies` implies `MultiParamTypeClasses`, and `RebindableSyntax` implies `NoImplicitPrelude`.

The input is processed from left to right. An extension (e.g., `StarIsType`) may be overridden later (e.g., by `NoStarIsType`).

Extensions that appear earlier in the input will appear later in the output. Implied extensions appear in the end. If an extension occurs multiple times in the input, the last one is used.

    >>> parseExtensions ["GADTs", "RebindableSyntax", "StarIsType", "GADTs", "InvalidExtension", "NoStarIsType"]
    ([GADTs, RebindableSyntax, GADTSyntax, MonoLocalBinds], [StarIsType, ImplicitPrelude], ["InvalidExtension"])