Remove DT_Failed state

At the moment if `-dynamic-too` fails then we rerun the whole pipeline
as if we were just in `-dynamic` mode. I argue this is a misfeature and
we should remove the so-called `DT_Failed` mode.

In what situations do we fall back to `DT_Failed`?

1. If the `dyn_hi` file corresponding to a `hi` file is missing completely.
2. If the interface hash of `dyn_hi` doesn't match the interface hash of `hi`.

What happens in `DT_Failed` mode?

* The whole compiler pipeline is rerun as if the user had just passed `-dynamic`.
* Therefore `dyn_hi/dyn_o` files are used which don't agree with the
  `hi/o` files. (As evidenced by `dynamicToo001` test).
* This is very confusing as now a single compiler invocation has
  produced further `hi`/`dyn_hi` files which are different to each
  other.

Why should we remove it?

* In `--make` mode, which is predominately used `DT_Failed` does not
  work (#19782), there can't be users relying on this functionality.
* In `-c` mode, the recovery doesn't fix the root issue, which is the
  `dyn_hi` and `hi` files are mismatched. We should instead produce an
  error and pass responsibility to the build system using `-c` to ensure
  that the prerequisites for `-dynamic-too` (dyn_hi/hi) files are there
  before we start compiling.
* It is a misfeature to support use cases like `dynamicToo001` which
  allow you to mix different versions of dynamic/non-dynamic interface
  files. It's more likely to lead to subtle bugs in your resulting
  programs where out-dated build products are used rather than a
  deliberate choice.
* In practice, people are usually compiling with `-dynamic-too` rather
  than separately with `-dynamic` and `-static`, so the build products
  always match and `DT_Failed` is only entered due to compiler bugs (see
  !6583)

What should we do instead?

* In `--make` mode, for home packages check during recompilation
  checking that `dyn_hi` and `hi` are both present and agree, recompile
  the modules if they do not.
* For package modules, when loading the interface check that `dyn_hi`
  and `hi` are there and that they agree but fail with an
  error message if they are not.
* In `--oneshot` mode, fail with an error message if the right files
  aren't already there.

Closes #19782 #20446 #9176 #13616

1 files changed, 1 insertions, 3 deletions

diff --git a/compiler/GHC/Driver/Main.hs b/compiler/GHC/Driver/Main.hs
index 1d36a83445..365807fad8 100644
--- a/compiler/GHC/Driver/Main.hs
+++ b/compiler/GHC/Driver/Main.hs
@@ -989,7 +989,7 @@ hscMaybeWriteIface logger dflags is_simple iface old_iface mod_location = do
       --
       let no_change = old_iface == Just (mi_iface_hash (mi_final_exts iface))
 
-      dt <- dynamicTooState dflags
+      let dt = dynamicTooState dflags
 
       when (logHasDumpFlag logger Opt_D_dump_if_trace) $ putMsg logger $
         hang (text "Writing interface(s):") 2 $ vcat
@@ -1003,7 +1003,6 @@ hscMaybeWriteIface logger dflags is_simple iface old_iface mod_location = do
             write_iface dflags iface
             case dt of
                DT_Dont   -> return ()
-               DT_Failed -> return ()
                DT_Dyn    -> panic "Unexpected DT_Dyn state when writing simple interface"
                DT_OK     -> write_iface (setDynamicNow dflags) iface
          else case dt of
@@ -1011,7 +1010,6 @@ hscMaybeWriteIface logger dflags is_simple iface old_iface mod_location = do
                DT_OK   | not no_change             -> write_iface dflags iface
                -- FIXME: see no_change' comment above
                DT_Dyn                              -> write_iface dflags iface
-               DT_Failed | not (dynamicNow dflags) -> write_iface dflags iface
                _                                   -> return ()
 
       when (gopt Opt_WriteHie dflags) $ do