Parsing problem with ghc-8.2.1

[ruomad]

It seems the messages when loading a file have changed with ghc-8.2.1.
I got the error "Unexpected response from haskell process".
After looking into it, I fixed it by changing the regex in haskell-load.el. My patch is :

--- Source/hs/haskell-load.el 2017-09-06 12:24:28.341913600 +0200
+++ .emacs.d/elpa/haskell-mode-20170903.948/haskell-load.el 2017-09-06 12:30:54.954209500 +0200
@@ -107,11 +107,11 @@
(let* ((ok (cond
((haskell-process-consume
process

•            "Ok, modules loaded: \\(.+\\)\\.$")
  

•            "Ok, \\([[:digit:]]+ \\)?modules? loaded[.:]\\(.*\\)$")
            t)
           ((haskell-process-consume
             process
  

•            "Failed, modules loaded: \\(.+\\)\\.$")
  

•            "Failed, \\([[:digit:]]+ \\)?modules? loaded[.:]\\(.*\\)$")
            nil)
           (t
            (error (message "Unexpected response from haskell process.")))))
  

I didn't check it's working on previous ghc versions, but it's meant to do it.

[gracjan]

Relevant #1168.

[alios]

I'am working on making interactive working again as well. The 2 things I've done so far are:

Added --ghci-options=-fno-diagnostics-show-caret" to my haskell-process-args-stack-ghci in .emacs.

 '(haskell-process-args-stack-ghci
   (quote
    ("--ghci-options=-ferror-spans" "--ghci-options=-fno-diagnostics-show-caret" "--no-build" "--no-load")))

Thia sisables the new (very nice) ghc8.2 error messages with source code snippets, as it seems not to be supported by the error parser yet.

In #1555
I added a config option to disable the issuing the :set prompt2 command to ghci when starting up interactive as it creates a warning in ghc-8.2.1.

Next step would be to fix/extend the error parsers.

[alios]

As mentioned by @ruomad the problem sits in haskell-load.el.

To illustrate the changes between before/after ghc 8.2. I tested the load on the shell with both versions and both cases (one or multiple modules loaded).

Behavior ghc-8.0.2:

[~/src/alios-cats]$ stack ghci --resolver=lts-9.4 --ghci-options=-ferror-spans                                                                           
alios-cats-0.1.0.0: configure (lib)
Configuring alios-cats-0.1.0.0...
alios-cats-0.1.0.0: initial-build-steps (lib)
Configuring GHCi with the following packages: alios-cats
GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Lib              ( /Users/alios/src/alios-cats/src/Lib.hs, interpreted )
Ok, modules loaded: Lib.
Loaded GHCi configuration from /private/var/folders/rq/lpz047951cb5jqzl0x67mjrc0000gn/T/ghci42813/ghci-script
*Lib Lib> 
Leaving GHCi.

[~/src/alios-cats]$ stack ghci --resolver=lts-9.4 --ghci-options=-ferror-spans                                                                           
alios-cats-0.1.0.0: initial-build-steps (lib)
Configuring GHCi with the following packages: alios-cats
GHCi, version 8.0.2: http://www.haskell.org/ghc/  :? for help
[1 of 2] Compiling SHA256           ( /Users/alios/src/alios-cats/src/SHA256.hs, interpreted )
[2 of 2] Compiling Lib              ( /Users/alios/src/alios-cats/src/Lib.hs, interpreted )
Ok, modules loaded: Lib, SHA256.
Loaded GHCi configuration from /private/var/folders/rq/lpz047951cb5jqzl0x67mjrc0000gn/T/ghci42986/ghci-script
*Lib Lib> 

Behavior ghc-8.2.1:

[~/src/alios-cats]$ stack ghci --ghci-options=-ferror-spans                                                                                              
alios-cats-0.1.0.0: initial-build-steps (lib)
Configuring GHCi with the following packages: alios-cats
GHCi, version 8.2.1: http://www.haskell.org/ghc/  :? for help
[1 of 1] Compiling Lib              ( /Users/alios/src/alios-cats/src/Lib.hs, interpreted )
Ok, 1 module loaded.
Loaded GHCi configuration from /private/var/folders/rq/lpz047951cb5jqzl0x67mjrc0000gn/T/ghci43629/ghci-script
*Lib Lib>

[~/src/alios-cats]$ stack ghci --ghci-options=-ferror-spans                                                                                              
alios-cats-0.1.0.0: initial-build-steps (lib)
Configuring GHCi with the following packages: alios-cats
GHCi, version 8.2.1: http://www.haskell.org/ghc/  :? for help
[1 of 2] Compiling SHA256           ( /Users/alios/src/alios-cats/src/SHA256.hs, interpreted )
[2 of 2] Compiling Lib              ( /Users/alios/src/alios-cats/src/Lib.hs, interpreted )
Ok, 2 modules loaded.
Loaded GHCi configuration from /private/var/folders/rq/lpz047951cb5jqzl0x67mjrc0000gn/T/ghci43024/ghci-script
*Lib Lib> 
Leaving GHCi.

Try to fix:

The change from 8.02 to 8.2.1 are:

• from Ok, modules loaded: Lib, SHA256. to Ok, 2 modules loaded. for 2 modules
• from Ok, modules loaded: Lib. to Ok, 1 module loaded. for 1 module

So I added another condition to haskell-load.el, the one with the regexp "Ok, ([[:digit:]]+) modules? loaded.$":

(defun haskell-process-load-complete (session process buffer reload module-buffer &optional cont)
  "Handle the complete loading response. BUFFER is the string of
text being sent over the process pipe. MODULE-BUFFER is the
actual Emacs buffer of the module being loaded."
  (when (get-buffer (format "*%s:splices*" (haskell-session-name session)))
    (with-current-buffer (haskell-interactive-mode-splices-buffer session)
      (erase-buffer)))
  (let* ((ok (cond
              ((haskell-process-consume
                process
                "Ok, modules loaded: \\(.+\\)\\.$")
               t)
              ((haskell-process-consume
                process
                "Ok, ([[:digit:]]+) modules? loaded.$")
               t)
              ((haskell-process-consume
                process
                "Failed, modules loaded: \\(.+\\)\\.$")
               nil)
              (t
               (error (message "Unexpected response from haskell process.")))))
         (modules (haskell-process-extract-modules buffer))
         (cursor (haskell-process-response-cursor process))
         (warning-count 0))

But existing regex is used match a group (the comma seperated list of module names), which no longer exists in ghci 8.2. So my matcher works But I don't have the string with the modules which seems to be used further down in the chain.

[zenspider]

@alios your code is missing 2 close parens and your regexp is incorrect. Remove the parens in the regexp or double backslash them. Since you're capturing the count of modules and that isn't used, you can drop them.

I'm still trying to figure out how to get the modules printing so they can be introspected properly... but I don't know ghc's flags at all.

[zenspider]

Actually you need the parens so it has SOMETHING to process as module names, even if it is just a number.

[treblacy]

The module list seems to be only important if you turn on haskell-process-reload-with-fbytecode or you turn on haskell-process-auto-import-loaded-modules.

I turn them off (never needed them) so I'm doing OK. But I can't speak for other people's use cases.

[swilde]

The relevant change in ghc is
https://phabricator.haskell.org/D3651
so this functionality is lost and there is no command line option to
get it back.

But it should be possible to get the necessary information from
":show modules" which might be the better solution anyways...

[swilde]

Btw, the way, the changes in haskell-load.el need to match the case of failure, too.

[peti]

Is anyone aware of a solution to the problems with GHC 8.2.1, or at least of a way to work around them? It's rather unpleasant that haskell-mode doesn't support that compiler properly at the moment since many projects switch to the new GHC version and it's getting more and more difficult (for me) to stick to 8.0.x. Any help remedying this issue would be very much appreciated.

[ksjogo]

Did someone talk to some upstream developers/has connections? Some machine readable output would be interesting to have behind some flag.

[ryukinix]

Fixing the @alios solution I got my code loaded again... But I don't know if will work always and the modules names are missing because the breaking change of new ghc, as people above commented.

(defun haskell-process-load-complete (session process buffer reload module-buffer &optional cont)
  "Handle the complete loading response. BUFFER is the string of
text being sent over the process pipe. MODULE-BUFFER is the
actual Emacs buffer of the module being loaded."
  (when (get-buffer (format "*%s:splices*" (haskell-session-name session)))
    (with-current-buffer (haskell-interactive-mode-splices-buffer session)
      (erase-buffer)))
  (let* ((ok (cond
              ((haskell-process-consume
                process
                "Ok, modules loaded: \\(.+\\)\\.$")
               t)
              ((haskell-process-consume  ;; new condition
                process
                "Ok, \\([[:digit:]]+\\) modules? loaded.$")
               t)
              ((haskell-process-consume
                process
                "Failed, modules loaded: \\(.+\\)\\.$")
               nil)
              (t
               (error (message "Unexpected response from haskell process.")))))
         (modules (haskell-process-extract-modules buffer))
         (cursor (haskell-process-response-cursor process))
         (warning-count 0))
    (haskell-process-set-response-cursor process 0)
    (haskell-check-remove-overlays module-buffer)
    (while
        (haskell-process-errors-warnings module-buffer session process buffer)
      (setq warning-count (1+ warning-count)))
    (haskell-process-set-response-cursor process cursor)
    (if (and (not reload)
             haskell-process-reload-with-fbytecode)
        (haskell-process-reload-with-fbytecode process module-buffer)
      (haskell-process-import-modules process (car modules)))
    (if ok
        (haskell-mode-message-line (if reload "Reloaded OK." "OK."))
      (haskell-interactive-mode-compile-error session "Compilation failed."))
    (when cont
      (condition-case-unless-debug e
          (funcall cont ok)
        (error (message "%S" e))
        (quit nil)))))

@peti I think you can at least silent the useless errors with it...

[peti]

@ryukinix, thank you very much for the updated patch. It does remedy the parser errors when loading a module, indeed, but another significant problem remains, i.e. Emacs still fails with a "parse error" in case the loaded Haskell module contains syntax errors. With ghc 8.0.x and before, Haskell mode would display those error messages in the ghci process buffer, but with 8.2.x it no longer does. This makes development with 8.2 pretty much unpractical, still. 😞

[ryukinix]

I'm glad that this helped in someway. Sad about the syntax errors, I understand that this is not good enough... would be nice if the GHC developers instead of just removing features because they THINK that no ones use, just disable by default and keep some flag to be possible enable again... as the commit that @swilde attached on this thread, seems that doesn't exists such thing. They just removed all the shit :/

We need to figure out another approach to handling this cases... more hacks? 😆