eduardsergeev / vscode-haskutil

QuickFix actions for Haskell in VSCode

VSCode Haskutil

'QuickFix' actions for Haskell editor

Requirements

This extension uses diagnostics (errors and warnings) from PROBLEMS tab which is populated by other Haskell extensions such as Simple GHC, Haskero, ghcid or ghcide. Please install one of them along with this extension.

Features

• Add missing import
• Organize imports
• Remove unused imports
• Add missing LANGUAGE extension
• Organize LANGUAGE extensions
• Add top-level signature
• Fill typed hole

Individual features can be turned on and off via haskutil.feature.[feature] flags

Add missing import

Uses Hoogle to search for matching modules. Configurable via hoogle-vscode extension configuration (can be configured to use local instance of hoogle for example).

Organize imports

Sorting and alignment are configurable via haskutil.sortImports and haskutil.alignImports respectively. Imports can also be organized on file save with haskutil.organiseImportsOnSave: true (dafault is false).

Remove unused imports

Removes unused imports identified by warnings. haskutil.alignImports controls if remaning imports are also aligned.

Add missing LANGUAGE extension

Adds LANGUAGE pragma suggested by error. List of supported pragmas is defined by haskutil.supportedExtensions.

Organize LANGUAGE extensions

Splitting, sorting and alignment of extensions are configurable via haskutil.splitExtensions, haskutil.sortExtensions and haskutil.alignExtensions respectively. Extensions can also be organized on file save with haskutil.organiseExtensionOnSave: true (dafault is false).

Add top-level signature

Adds signature suggested by warning.

Fill typed hole

Replaces typed hole with one of the valid hole fits from the warning.
Similarly replaces type wildcard with inferred type.

Dependencies

• Automatic dependency (auto install) hoogle-vscode

vscode-haskutil's Issues

Remove unused imports removes wrong entries from import list

Example:
With the following warning:

The import of ‘NetworkTag’
from module ‘Cardano.Address’ is redundant

And the following import statement:

import           Cardano.Address (NetworkTag(..), bech32)

Applying quick fix leads to:

import           Cardano.Address (NetworkTag(..))

Avoid suggesting unnecessary module name alias

👋 Hi! Thanks for the great tool. I've been using it recently with the simple GHC extension in VSCode. I ran into a tiny little issue that I think comes from this extension, but please point me elsewhere if that's not the case.

When suggesting an import the aliased name can be the same as the module name. For example trying to use Say.sayShow correctly suggests importing Say, but unfortunately also suggests aliasing the import:

This isn't wrong, but it is a little surprising and unnecessary. Instead of suggesting import qualified Say as Say, it would be nice if haskutil suggested import qualified Say.

Intermittent test failures

Integration tests intermittently fail on CI with Error: Timeout of 30000ms exceeded message.
Not sure why, test might not be seeing expected number of Haskell diagnostic messages (required by tests?

Organize import can produce code that the extension considers unorganized

Steps to reproduce:

1. Put this in a file

   import           Data.Hashable (Hashable)
   import qualified Data.HashMap.Strict as HM

2. See that Haskutil complains that imports are unorganized.
3. Select 'Organize imports'. Code is not changed.
4. Save file. Haskutil still complains that imports are unorganized.

Tried on VSCode 1.44.1, Haskutil 0.8.0

Constraint hole fill may use weird syntax and may need ConstraintKinds

GHC reports the inferred constraints in the form of a tuple, but such a tuple is not necessarily the best syntax to use, and nested constraint tuples require -XConstraintKinds. See examples:

f0 :: (Num a, _) => a -> a
-- Result: f0 :: (Num a, ()) => a -> a
-- Not idiomatic and needs -XConstraintKinds
-- Ideal: f0 :: (Num a) => a -> a or f0 :: Num a => a -> a
f0 x = x + x

f3 :: (Num a, _) => a -> Bool
-- Result: f3 :: (Num a, (Eq a, Read a, Show a)) => a -> Bool
-- Needs -XConstraintKinds
-- Ideal: f3 :: (Num a, Eq a, Read a, Show a) => a -> Bool
f3 x = read (show $ x + x) == x

fe :: _ => a -> a
-- Result: fe :: () => a -> a
-- Ideal: fe :: a -> a
fe x = x

Remove extra spaces in LANGUAGE when organising them

So this:

{-# LANGUAGE DataKinds                          #-}
{-# LANGUAGE DeriveGeneric                      #-}
{-# LANGUAGE DuplicateRecordFields              #-}
{-# LANGUAGE FlexibleContexts                   #-}
{-# LANGUAGE GeneralizedNewtypeDeriving         #-}
{-# LANGUAGE LambdaCase                         #-}
{-# LANGUAGE MultiParamTypeClasses              #-}
{-# LANGUAGE OverloadedStrings                  #-}
{-# LANGUAGE RecordWildCards                    #-}
{-# LANGUAGE StandaloneDeriving                 #-}
{-# LANGUAGE TypeApplications                   #-}
{-# LANGUAGE TypeOperators                      #-}

Should is converted into:

{-# LANGUAGE DataKinds                  #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE DuplicateRecordFields      #-}
{-# LANGUAGE FlexibleContexts           #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase                 #-}
{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE RecordWildCards            #-}
{-# LANGUAGE StandaloneDeriving         #-}
{-# LANGUAGE TypeApplications           #-}
{-# LANGUAGE TypeOperators              #-}

Add classes and constructors with '(..)' when adding missing imports

Currently when class or constructor is not in scope the only option offered is Add: "import Module.Name (ClassName)".
It should also propose to add import Module.Name (ClassName(..)) which should also be default/preferable option.

Constraint hole fill is broken on GHC 8.8

Since GHC 8.8 the error messages of constraint holes have range of the entire type signature rather than just the hole, which means filling the hole destroys the type signature:

fn :: _ => a -> a
--    ^^^^^^^^^^^ Error message range
-- Result: fn :: Num a
fn x = x + x

It makes some sense because the constraint wildcards are only allowed at the top level:

ghci> :t (undefined :: (_ => Int) -> Int)

<interactive>:1:16: error:
    Wildcard ‘_’ not allowed in a constraint
      except as the last top-level constraint of a type signature
        e.g  f :: (Eq a, _) => blah
      in an expression type signature

To solve this a crude parser might be needed to go through the rough structure [forall ... .] [(..., _) => | _ =>] ... at the beginning of the type signature to cover common cases.