GitLab

Otherwise it defaults to latin1.

In standalone deriving, we now do *not* check side conditions.
We simply generate the code and typecheck it.  If there's a type
error, it's the programmer's problem. 

This means that you can do 'deriving instance Show (T a)', where
T is a GADT, for example, provided of course that the boilerplate
code does in fact typecheck.

I put some work into getting a decent error message.  In particular
if there's a type error in a method, GHC will show the entire code
for that method (since, after all, the user did not write it).
Most of the changes are to achieve that goal.

Still to come: changes in the documentation.

This makes the code printed by -ddump-deriv look prettier

When reporting an error from a failed equality constraint, we were
setting the *context* but not the *line number* in TcTyFuns.eqInstMisMatch
As a result, the line number didn't match the context at all.  It's
trivial to fix.

I'm 99% certain this fixes #3193, but it's too complicated to
reproduce, so I have not actually tested it.

This function isn't used at the moment, but Max added it, and it
looks useful.

This patch adds tuple sections, so that

	(x,,z)  means   \y -> (x,y,z)

Thanks for Max Bolinbroke for doing the hard work.

In the end, instead of using two constructors in HsSyn, I used
just one (still called ExplicitTuple) whose arguments can be
	Present (LHsExpr id)
or	Missing PostTcType

While I was at it, I did a bit of refactoring too.

redefinition warnings for all files that are including includes/Rts.h.

Contributed by: Krister Walfridsson <krister.walfridsson@gmail.com>

Rather than indirecting through an integer package

Now, for a compiler-generated binding "x", if "x" is referred to by
the exported "f", then it will be named "f_x" rather than something
like "x23".  This means that hopefully

  - compilation will more often product the same results given the
    same input (the choice of names is not dependent on the
    non-deterministic order of bindings within the compiler).

  - less recompilation will be necessary after making changes

  - navigating Core might be a bit easier.

unfortunately, compilation with -O still does not consistently produce
the same ABI.  The simplifier sometimes does different things,
apparently.

Names will be longer, but I can't see a way around that.

Fixes another cause of wobbly interface files and unnecessary recompilation.

When matching against a GADT, some of the constructors may be impossible.
For example
	data T a where
          T1 :: T Int
          T2 :: T Bool
          T3 :: T a

        f :: T Int -> Int
        f T1 = 3
        f T3 = 4

Here, does not have any missing cases, despite omittting T2, because
T2 :: T Bool.

This patch teaches the overlap checker about GADTs, which happily
turned out to be rather easy even though the overlap checker needs
a serious rewrite.

Max spotted that the short-cut rules for desugaring NPats (where
we compare against a literal) were wrong now that we have overloaded
strings.

This is used to control warnings that were previously unconditional.

If Windows wasn't defined properly then the Win32 package wasn't being
cleaned, as it wasn't added to PACKAGES. Now we always add everything to
PACKAGES when CLEANING=YES.

This avoids a collision between the directories we use when compiling
multiple ways, which in turn leads to a race condition in parallel
builds.

This means that, provided the values are small enough, files
serialized are portable between architectures. In particular,
.haddock files are portable.