Apologies -- there was some git confusion that cause the Wrong Thing
to happen.

This reverts commit bb9d53e3.

Conflicts:

	compiler/hsSyn/Convert.lhs

Now, instead of looking at a class's roles, the GND check looks
at all of the methods in the class individually. This has the
advantage that sometimes, we can use information about the
derivation requested during the safety check. For example,
we can now derive (IArray UArray), whereas the previous check
prevented this.

Now, we allow types that do not begin with ':', but we retain other
checks on variable names.

This was quite simple -- just use mkIntegerExpr instead of mkIntExpr.

This was easy to do, except that the desugar monad needs a
FamInstEnv init.  Straightforward, routine, albeit a bit clunky.

We weren't dealing with built-in syntax; data constructors
that are built-in syntax (only [] actually) don't appear
in the GlobalRdrEnv

and add new, simpler topNormaliseType

This is just a minor refactoring

Signed-off-by: Edward Z. Yang <ezyang@mit.edu>

Fixes #8456. Previous version of control flow optimisations
did not update the list of block predecessors, leading to
unnecessary duplication of blocks in some cases. See Trac
and comments in the code for more details.

The only substantive change here is to change "==" into ">=" in
the Note [Always false stack check] code.  This is semantically
correct, but won't have any practical impact.

This patches fixes two separate instances of the bug,

 * one in tc_ax_branches (Trac #8449)

 * one in type/kind applications in IfaceExpr
   (hence the new tcIfaceApps)

The latter was reported by Iavor, no ticket

Fix a bug introduced in 94125c97.
See Note [Always false stack check]

This fixes #8452.

Compiled HscMain.o is now smaller.

I am removing old loopification code that has been commented out
for long long time. We now have loopification implemented in
the code generator (see Note [Self-recursive tail calls]) so we
won't need to resurect this old code.

When compiling a function we can determine how much stack space it will
use. We therefore need to perform only a single stack check at the beginning
of a function to see if we have enough stack space. Instead of referring
directly to Sp - as we used to do in the past - the code generator uses
(old + 0) in the stack check. Stack layout phase turns (old + 0) into Sp.

The idea here is that, while we need to perform only one stack check for
each function, we could in theory place more stack checks later in the
function. They would be redundant, but not incorrect (in a sense that they
should not change program behaviour). We need to make sure however that a
stack check inserted after incrementing the stack pointer checks for a
respectively smaller stack space. This would not be the case if the code
generator produced direct references to Sp. By referencing (old + 0) we make
sure that we always check for a correct amount of stack: when converting
(old + 0) to Sp the stack layout phase takes into account changes already
made to stack pointer. The idea for this change came from observations made
while debugging #8275.