GitLab

Can't check $(GhcUnregisterised) eagerly, because it might not have
been set yet (it's set in build.mk).

When I rejigged constraint simplification when inferring types, I missed
a corner case.  Somethign that it's distressingly easy to do.  Anyway
this fixes it; see the comments in tcSimplifyInfer with the second call
to partition and extendLIEs.

The test is tcfail181.

This used to be a parse error, but ! annotations are now handled
further downstream in the compiler, and I'd forgotten to check
that newtypes do not have strictness annotations.

The test read008 is technically in the wrong place (it's a typechecker
test now) but that doesn't matter

Currently, when the user invokes the GHCi editor without a parameter
GHCi chooses the last file that loaded _sucessfully_.
This patch changes this behavior to start the editor with the
last file that _faild_ (this being what I usually want to edit).
Caveat: we use the module graph to determine what happened
and so we do not catch errors that occured during dependecy
analysis (e.g., a mis-typed module name) but we could fix this later.

I reorganized the lexing of numeric literals a bit so the code didn't
get too ugly, after trying a few ways, and also considering possible plans
to be able to conditionally lex negative _boxed_ literals.

I decided against adding parseSignedInteger since octal
and hex literals often have junk between the '-' and the
digits, but, compare to Util.readRational which does handle
signed numbers.  Also since Integers - mathematically and
in Haskell - can be negative, normally.

It doesn't work yet, but I'm pretty sure that's because the bindist is
broken rather than the installer is broken.

Not done by default yet, but useful when hacking on libraries.

Roman produced programs involving associated types that did not optimise well.
His programs were something like this:

  data family T a
  data instance T Int = MkT Bool Char

  bar :: T Int -> Int
  bar t = t `seq` loop 0
	where
	  loop = ...

You'd think that the `seq` should unbox 't' outside the loop, since
a (T Int) is just a MkT pair.  

The most robust way to make this happen is for the simplifier to understand
a bit about type-family instances.   See 
	Note [Improving seq]
in Simplify.lhs.  We use FamInstEnv.topNormaliseType to do the interesting
work.

To make this happen I did a bit of refactoring to the simplifier
monad.

I'd previously done a very similar transformation in LiberateCase, but it
was happening too late.  So this patch takes it out of LiberateCase as
well as adding it to Simplify.

Consder Trac #1265, which does this in GHCi:

	Prelude> let doit = fail "Code not written yet" :: ExpQ
	Prelude> $(doit)

Even though 'doit' is defined "in the same module", it's OK to use it in a splice
because it'll have been fully compiled to bytecode.  (Contrast the situation if
these two lines appeared in a single, compiled module.)

Hence we want to bind 'doit' at TH's "imported level" (TcRnTypes.impLevel).  
This used to happen because GHCi-bound Ids were in the *global* type
env (and hence at "imported level").  But since SimonM moved
GHCi-bound ids to the *local* type env (for good reasons) the above
program has been rejected.

This patch makes it work again.