GitLab

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.

2 reasons for this:
  - compilation is more predictable.  Adding or removing an instance
    is less likely to force unnecessary recompilation due to
    renumbering other dfun names.
  - it makes it easier to read Core / C-- / asm

The names aren't completely deterministic.  To do that, we'd have to
include package and module names, which would make the symbol names
long and reduce readability.  So the compromise is that if there's a
clash, we disambiguate by adding an integer suffix.  This is fairly
unlikely in practice unless you're using overlapping instances.

Type family instances are handled in the same way, with the same
disambiguation strategy.

The export list was ordered according to the whim of FastStrings,
which meant that interface fingerprints could change for no good
reason, causing spurious recompilation.

Instead, we just put the flags we need in there (e.g. -m64 on OS X 64).
This fixes a problem found by Simon M, where we were compiling
everything with -g, leading to a bloated RTS.

Also, libdir is now part of the --info output, so this subsumes the old
--print-libdir flag.
The mode parsing was getting rather adhoc, so I've tidied it up a bit
in the process.

Patch from
    Max Bolingbroke <batterseapower@hotmail.com>
Rerecorded to avoid conflicts.