Warn about simplifiable class constraints

Provoked by Trac #11948, this patch adds a new warning to GHC

  -Wsimplifiable-class-constraints

It warns if you write a class constraint in a type signature that
can be simplified by an existing instance declaration.  Almost always
this means you should simplify it right now; type inference is very
fragile without it, as #11948 shows.

I've put the warning as on-by-default, but I suppose that if there are
howls of protest we can move it out (as happened for -Wredundant-constraints.

It actually found an example of an over-complicated context in CmmNode.

Quite a few tests use these weird contexts to trigger something else,
so I had to suppress the warning in those.

The 'haskeline' library has a few occurrences of the warning (which
I think should be fixed), so I switched it off for that library in
warnings.mk.

The warning itself is done in TcValidity.check_class_pred.

HOWEVER, when type inference fails we get a type error; and the error
suppresses the (informative) warning.  So as things stand, the warning
only happens when it doesn't cause a problem.  Not sure what to do
about this, but this patch takes us forward, I think.

1 files changed, 22 insertions, 0 deletions

diff --git a/docs/users_guide/using-warnings.rst b/docs/users_guide/using-warnings.rst
index 16c6585caf..72e7748dbe 100644
--- a/docs/users_guide/using-warnings.rst
+++ b/docs/users_guide/using-warnings.rst
@@ -713,6 +713,28 @@ of ``-W(no-)*``.
     second pattern overlaps it. More often than not, redundant patterns
     is a programmer mistake/error, so this option is enabled by default.
 
+.. ghc-flag:: -Wsimplifiable-class-constraints
+
+    :since: 8.2
+
+    .. index::
+       single: simplifiable class constraints, warning
+
+    Warn about class constraints in a type signature that can be simplified
+    using a top-level instance declaration.  For example: ::
+
+       f :: Eq [a] => a -> a
+
+    Here the ``Eq [a]`` in the signature overlaps with the top-level
+    instance for ``Eq [a]``.  GHC goes to some efforts to use the former,
+    but if it should use the latter, it would then have an
+    insoluble ``Eq a`` constraint.  Best avoided by instead writing: ::
+
+       f :: Eq a => a -> a
+
+    This option is on by default. As usual you can suppress it on a
+    per-module basis with :ghc-flag:`-Wno-simplifiable-class-constraints`.
+
 .. ghc-flag:: -Wtabs
 
     .. index::