Trim imports

Yet another fix to an old hi-boot-6 file

Kinding wibble in TH brackets

Use extraGHCiLibraries (if supplied) in GHCi linker rather than extraLibraries
Also extend the parser.

combine libraries/.darcs-boring and .darcs-boring

Fix long-standing bug in CPR analysis

MERGE TO STABLE

For a long time (2002!) the CPR analysis done by
dmdAnalTopRhs has been bogus.  In particular, it's possible
for a newtype constructor to look CPR-ish when it simply isn't.

This fixes it.  Test is stranal/newtype

More hi-boot-6 updates

Fix TcUnify.subFunTys in AppTy case

subFunTys wasn't dealing correctly with the case where the type
to be split was of form (a ty1), where a is a type variable.

This shows up when compiling
Control.Arrow.Transformer.Stream
in package arrows.

This commit fixes it.

Error message wibble

Add mkHsCoerce to avoid junk in typechecked code

Avoiding identity coercions is a Good Thing generally, but
it turns out that the desugarer has trouble recognising
'otherwise' and 'True' guards if they are wrapped in an
identity coercion; and that leads to bogus overlap warnings.

Improve error messsage when argument count varies

fix bug #664 in printSample()
printSample() was attempting to round the fractional part of the time,
but not propagated to the non-fractional part.  It's probably better not
to attempt to round the time at all.

Fix hi-boot file for earlier versions of GHC

Fix typo in boxy matching

fix one case where -q wasn't honoured

Check for GMP.framework on all Darwin platforms, not just PPC

Simon's big boxy-type commit

This very large commit adds impredicativity to GHC, plus
numerous other small things.

*** WARNING: I have compiled all the libraries, and
***      a stage-2 compiler, and everything seems
***      fine.  But don't grab this patch if you
***      can't tolerate a hiccup if something is
***      broken.

The big picture is this:

a) GHC handles impredicative polymorphism, as described in the
   "Boxy types: type inference for higher-rank types and
   impredicativity" paper

b) GHC handles GADTs in the new simplified (and very sligtly less
   epxrssive) way described in the
   "Simple unification-based type inference for GADTs" paper

But there are lots of smaller changes, and since it was pre-Darcs
they are not individually recorded.

Some things to watch out for:

c)   The story on lexically-scoped type variables has changed, as per
     my email.  I append the story below for completeness, but I
     am still not happy with it, and it may change again.  In particular,
     the new story does not allow a pattern-bound scoped type variable
     to be wobbly, so (\(x::[a]) -> ...) is usually rejected.  This is
     more restrictive than before, and we might loosen up again.

d)   A consequence of adding impredicativity is that GHC is a bit less
     gung ho about converting automatically between
   (ty1 -> forall a. ty2)    and    (forall a. ty1 -> ty2)
     In particular, you may need to eta-expand some functions to make
     typechecking work again.

     Furthermore, functions are now invariant in their argument types,
     rather than being contravariant.  Again, the main consequence is
     that you may occasionally need to eta-expand function arguments when
     using higher-rank polymorphism.

Please test, and let me know of any hiccups

Scoped type variables in GHC
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
January 2006

0) Terminology.

   A *pattern binding* is of the form
pat = rhs

   A *function binding* is of the form
f pat1 .. patn = rhs

   A binding of the formm
var = rhs
   is treated as a (degenerate) *function binding*.

   A *declaration type signature* is a separate type signature for a
   let-bound or where-bound variable:
f :: Int -> Int

   A *pattern type signature* is a signature in a pattern:
\(x::a) -> x
f (x::a) = x

   A *result type signature* is a signature on the result of a
   function definition:
f :: forall a. [a] -> a
head (x:xs) :: a = x

   The form
x :: a = rhs
   is treated as a (degnerate) function binding with a result
   type signature, not as a pattern binding.

1) The main invariants:

     A) A lexically-scoped type variable always names a (rigid)
  type variable (not an arbitrary type).  THIS IS A CHANGE.
        Previously, a scoped type variable named an arbitrary *type*.

     B) A type signature always describes a rigid type (since
its free (scoped) type variables name rigid type variables).
This is also a change, a consequence of (A).

     C) Distinct lexically-scoped type variables name distinct
rigid type variables.  This choice is open;

2) Scoping

2(a) If a declaration type signature has an explicit forall, those type
   variables are brought into scope in the right hand side of the
   corresponding binding (plus, for function bindings, the patterns on
   the LHS).
f :: forall a. a -> [a]
f (x::a) = [x :: a, x]
   Both occurences of 'a' in the second line are bound by
   the 'forall a' in the first line

   A declaration type signature *without* an explicit top-level forall
   is implicitly quantified over all the type variables that are
   mentioned in the type but not already in scope.  GHC's current
   rule is that this implicit quantification does *not* bring into scope
   any new scoped type variables.
f :: a -> a
f x = ...('a' is not in scope here)...
   This gives compatibility with Haskell 98

2(b) A pattern type signature implicitly brings into scope any type
   variables mentioned in the type that are not already into scope.
   These are called *pattern-bound type variables*.
g :: a -> a -> [a]
g (x::a) (y::a) = [y :: a, x]
   The pattern type signature (x::a) brings 'a' into scope.
   The 'a' in the pattern (y::a) is bound, as is the occurrence on
   the RHS.

   A pattern type siganture is the only way you can bring existentials
   into scope.
data T where
  MkT :: forall a. a -> (a->Int) -> T

f x = case x of
MkT (x::a) f -> f (x::a)

2a) QUESTION
class C a where
  op :: forall b. b->a->a

instance C (T p q) where
  op = <rhs>
    Clearly p,q are in scope in <rhs>, but is 'b'?  Not at the moment.
    Nor can you add a type signature for op in the instance decl.
    You'd have to say this:
instance C (T p q) where
  op = let op' :: forall b. ...
           op' = <rhs>
       in op'

3) A pattern-bound type variable is allowed only if the pattern's
   expected type is rigid.  Otherwise we don't know exactly *which*
   skolem the scoped type variable should be bound to, and that means
   we can't do GADT refinement.  This is invariant (A), and it is a
   big change from the current situation.

f (x::a) = x -- NO; pattern type is wobbly

g1 :: b -> b
g1 (x::b) = x -- YES, because the pattern type is rigid

g2 :: b -> b
g2 (x::c) = x -- YES, same reason

h :: forall b. b -> b
h (x::b) = x -- YES, but the inner b is bound

k :: forall b. b -> b
k (x::c) = x -- NO, it can't be both b and c

3a) You cannot give different names for the same type variable in the same scope
    (Invariant (C)):

f1 :: p -> p -> p -- NO; because 'a' and 'b' would be
f1 (x::a) (y::b) = (x::a) --     bound to the same type variable

f2 :: p -> p -> p -- OK; 'a' is bound to the type variable
f2 (x::a) (y::a) = (x::a) --     over which f2 is quantified
-- NB: 'p' is not lexically scoped

f3 :: forall p. p -> p -> p -- NO: 'p' is now scoped, and is bound to
f3 (x::a) (y::a) = (x::a) --     to the same type varialble as 'a'

f4 :: forall p. p -> p -> p -- OK: 'p' is now scoped, and its occurences
f4 (x::p) (y::p) = (x::p) --     in the patterns are bound by the forall

3b) You can give a different name to the same type variable in different
    disjoint scopes, just as you can (if you want) give diferent names to
    the same value parameter

g :: a -> Bool -> Maybe a
g (x::p) True  = Just x  :: Maybe p
g (y::q) False = Nothing :: Maybe q

3c) Scoped type variables respect alpha renaming. For example,
    function f2 from (3a) above could also be written:
f2' :: p -> p -> p
f2' (x::b) (y::b) = x::b
   where the scoped type variable is called 'b' instead of 'a'.

4) Result type signatures obey the same rules as pattern types signatures.
   In particular, they can bind a type variable only if the result type is rigid

f x :: a = x -- NO

g :: b -> b
g x :: b = x -- YES; binds b in rhs

5) A *pattern type signature* in a *pattern binding* cannot bind a
   scoped type variable

(x::a, y) = ... -- Legal only if 'a' is already in scope

   Reason: in type checking, the "expected type" of the LHS pattern is
   always wobbly, so we can't bind a rigid type variable.  (The exception
   would be for an existential type variable, but existentials are not
   allowed in pattern bindings either.)

   Even this is illegal
f :: forall a. a -> a
f x = let ((y::b)::a, z) = ...
      in
   Here it looks as if 'b' might get a rigid binding; but you can't bind
   it to the same skolem as a.

6) Explicitly-forall'd type variables in the *declaration type signature(s)*
   for a *pattern binding* do not scope AT ALL.

x :: forall a. a->a   -- NO; the forall a does
Just (x::a->a) = Just id  --     not scope at all

y :: forall a. a->a
Just y = Just (id :: a->a)  -- NO; same reason

   THIS IS A CHANGE, but one I bet that very few people will notice.
   Here's why:

strange :: forall b. (b->b,b->b)
strange = (id,id)

x1 :: forall a. a->a
y1 :: forall b. b->b
(x1,y1) = strange

    This is legal Haskell 98 (modulo the forall). If both 'a' and 'b'
    both scoped over the RHS, they'd get unified and so cannot stand
    for distinct type variables. One could *imagine* allowing this:

x2 :: forall a. a->a
y2 :: forall a. a->a
(x2,y2) = strange

    using the very same type variable 'a' in both signatures, so that
    a single 'a' scopes over the RHS.  That seems defensible, but odd,
    because though there are two type signatures, they introduce just
    *one* scoped type variable, a.

7) Possible extension.  We might consider allowing
\(x :: [ _ ]) -> <expr>
    where "_" is a wild card, to mean "x has type list of something", without
    naming the something.

add double colon and double arrow symbols (-fglasgow-exts)

Fix conDeclFVs for GADTs, to fix bogus unused-import warning

make the par# primop actually do something

Update Cachegrind support for changes to the Valgrind CLI

send usage info to stdout, not stderr

primop-docs

remove old CVS stuff, replace with darcs

implement clean/dirty TSOs
Along the lines of the clean/dirty arrays and IORefs implemented
recently, now threads are marked clean or dirty depending on whether
they need to be scanned during a minor GC or not.  This should speed
up GC when there are lots of threads, especially if most of them are
idle.

Better error message for Template Haskell pattern brackets

remove old comment

Fix for feature request #655 (Loading the GHC library from GHCi.)
Moved the utility functions out of hschooks, avoided
linking the GHC library with hschooks.o and
added a couple of symbols to the linkers export list.

Make hsc2hs emit the full path name in {-# LINE #-} pagmas.
For one thing this is the right thing to do anyway, it's what other tools do.
Secondly it allows haddock to produce accurate source code links.

MFLAGS += -f Makefile
merged from CVS, because Tailor isn't merging the libraries subdir

undo accidental commit of snapshot version

[project @ 2006-01-19 16:15:58 by simonmar]
omit the Main module from libHSghc.a

[project @ 2006-01-19 16:11:04 by simonmar]
exposed-modules should include Config

[project @ 2006-01-19 02:15:38 by sof]
tryPutMVarzh_fast: make it work in the non-full case.

Merge to STABLE.

test

respect the -q switch in this script

Hack around whatsnew failing if there are no changes

Pass anything through to darcs and let it do the failing on bad commands

[project @ 2006-01-18 12:16:06 by simonpj]
Check for constructors in type signatures

[project @ 2006-01-18 12:15:37 by simonpj]
Expunge all mention of CCallable/CReturnable

[project @ 2006-01-18 11:13:06 by simonpj]
Ghci wibble; weaken assert

[project @ 2006-01-18 11:00:35 by simonmar]
Remove dead code

[project @ 2006-01-18 10:59:54 by simonmar]
Remove dead panic

[project @ 2006-01-18 10:58:15 by simonmar]
Remove dead error

(darcs patch from Ian Lynagh)

[project @ 2006-01-18 10:49:32 by simonmar]
Implement :main (see ticket #662)

Patch from Volker Stolz, minor mods by me

When matching commands, we now look for (a) an exact match, and (b)
the first prefix match we find in the list.  This is so that :module
can still be abbreviated by :m, to avoid surprise.

Docs still to do.

[project @ 2006-01-18 10:40:46 by simonmar]
add a couple of missing symbols

[project @ 2006-01-18 10:31:50 by simonmar]
- fix a mixup in Capability.c regarding signals: signals_pending() is not
  used in THREADED_RTS

- some cleanups and warning removal while I'm here

[project @ 2006-01-18 10:06:36 by simonmar]
Fix build on 5.04.x again

[project @ 2006-01-17 16:13:18 by simonmar]
Improve the GC behaviour of IORefs (see Ticket #650).

This is a small change to the way IORefs interact with the GC, which
should improve GC performance for programs with plenty of IORefs.

Previously we had a single closure type for mutable variables,
MUT_VAR.  Mutable variables were *always* on the mutable list in older
generations, and always traversed on every GC.

Now, we have two closure types: MUT_VAR_CLEAN and MUT_VAR_DIRTY.  The
latter is on the mutable list, but the former is not.  (NB. this
differs from MUT_ARR_PTRS_CLEAN and MUT_ARR_PTRS_DIRTY, both of which
are on the mutable list).  writeMutVar# now implements a write
barrier, by calling dirty_MUT_VAR() in the runtime, that does the
necessary modification of MUT_VAR_CLEAN into MUT_VAR_DIRY, and adding
to the mutable list if necessary.

This results in some pretty dramatic speedups for GHC itself.  I've
just measureed a 30% overall speedup compiling a 31-module program
(anna) with the default heap settings :-D

[project @ 2006-01-17 16:03:47 by simonmar]
Improve the GC behaviour of IOArrays/STArrays

See Ticket #650

This is a small change to the way mutable arrays interact with the GC,
that can have a dramatic effect on performance, and make tricks with
unsafeThaw/unsafeFreeze redundant.  Data.HashTable should be faster
now (I haven't measured it yet).

We now have two mutable array closure types, MUT_ARR_PTRS_CLEAN and
MUT_ARR_PTRS_DIRTY.  Both are on the mutable list if the array is in
an old generation.  writeArray# sets the type to MUT_ARR_PTRS_DIRTY.
The garbage collector can set the type to MUT_ARR_PTRS_CLEAN if it
finds that no element of the array points into a younger generation
(discovering this required a small addition to evacuate(), but rough
tests indicate that it doesn't measurably affect performance).

NOTE: none of this affects unboxed arrays (IOUArray/STUArray), only
boxed arrays (IOArray/STArray).

We could go further and extend the DIRTY bit to be per-block rather
than for the whole array, but for now this is an easy improvement.

[project @ 2006-01-17 13:50:06 by simonmar]
statDescribeGens: count large blocks in the "live" figure

[project @ 2006-01-17 13:28:01 by simonmar]
take into account unscavenged copied words in +RTS -t stats.

[project @ 2006-01-17 02:13:16 by wolfgang]
Linux/PPC64: remove some dead code that accidentally slipped in.

MERGE TO STABLE

[project @ 2006-01-17 01:51:56 by wolfgang]
Darwin/PPC:
Make StgRunIsImplementedInAssembler non-static; gcc has recently acquired
a habit of dead-stripping it.

MERGE TO STABLE

[project @ 2006-01-16 16:38:24 by simonmar]
Default signal handlers weren't being installed; amazing that this has
been broken ever since I rearranged the signal handling code.

improvements to darcs-all
- get from the same repo as the main GHC repo, if that was a local filesystem
- allow darcs whatsnew
- use --repodir if possible

Add infrastructure for multiple library packages
The ./darcs-all script at the top level is an easier way to do darcs
pull/push/get on the whole tree (it should probably allow more
commands; I'll fix that later).

libraries/default-packages is a list of darcs repositories with which
to populate the libraries tree.

Add a skeleton libraries directory
Adding files from libraries that aren't in the other
packages sub-repos.  I haven't bothered to try to keep
history for these files, for history go back to the CVS
repo.

[project @ 2006-01-12 16:16:28 by simonmar]
GHC.runStmt: run the statement in a new thread to insulate the
environment from bad things that the user code might do, such as fork
a thread to send an exception back at a later time.  In order to do
this, we had to keep track of which thread the ^C exception should go
to in a global variable.

Also, bullet-proof the top-level exception handler in GHCi a bit;
there was a small window where an exception could get through, so if
you lean on ^C for a while then press enter you could cause GHCi to
exit.

[project @ 2006-01-12 14:42:25 by simonmar]
+RTS -S: replace "collected" with "copied", which is more useful.
+RTS -Dg: print size of mutable list, and breakdown by type of closure
(MUT_VAR, MUT_ARR, others).

[project @ 2006-01-12 13:49:24 by simonmar]
fix calculation of copied bytes, we had a words/bytes mismatch when
adding the size of the mutable list

[project @ 2006-01-12 12:41:03 by simonmar]
time_str:
  - use ctime_r if available
  - avoid use of strcpy on overlapping regions

Ticket #480 (patch modified by me)

[project @ 2006-01-12 12:40:01 by simonmar]
check for ctime_r

[project @ 2006-01-12 10:04:36 by simonmar]
Document that source files are ASCII or UTF-8

[project @ 2006-01-12 09:33:16 by simonmar]
put unicode keywords under -fglasgow-exts, they aren't Hasell98

[project @ 2006-01-11 16:58:53 by simonmar]
MAYBE_GC: we should check alloc_blocks in addition to CurrentNursery,
since some allocateLocal calls don't allocate from the nursery.

[project @ 2006-01-11 13:12:09 by simonmar]
fix string desugaring: we can only use the ASCII unpackCString# if all
the chars are <= 0x7F, not <= 0xFF.

(fixes recent breakage in nofib/real/compress2)

[project @ 2006-01-11 12:20:30 by simonmar]
Add -threaded when building stage2+ again

[project @ 2006-01-11 12:17:41 by simonmar]
understand Unicode lambda as a synonym for \

[project @ 2006-01-10 14:47:23 by simonmar]
Fix a comment

[project @ 2006-01-10 14:46:50 by simonmar]
Char primops: the Char# rep is wordRep, not I32 (fixed -dcmm-lint
problems on x86_64)

[project @ 2006-01-10 14:39:38 by simonmar]
prevChar: don't back up over decoding errors

[project @ 2006-01-10 14:39:01 by simonmar]
Add a TODO

[project @ 2006-01-10 14:37:53 by simonmar]
reportLexError: don't back up one character, the buffer returned by
Alex is the one *before* the erroneous lexeme started.

[project @ 2006-01-10 13:35:04 by simonmar]
Z-encode cost centre symbols when printing them out.

[project @ 2006-01-10 09:47:51 by simonmar]
Fix compilation with GHC 6.2.x, hopefully

[project @ 2006-01-10 09:05:18 by simonmar]
add file argument to docs for +RTS -t

[project @ 2006-01-09 14:38:01 by simonmar]
Initialise part of a structure to NULL to avoid a gcc warning
  I haven't checked the code on this one to be sure this isn't just a bug.

[project @ 2006-01-09 14:37:07 by simonmar]
Put entry_is_read_only and tvar_is_locked

[project @ 2006-01-09 14:35:53 by simonmar]
Avoid "dereferencing type-punned pointer will break strict-aliasing rules" warning

[project @ 2006-01-09 14:35:31 by simonmar]
Avoid "dereferencing type-punned pointer will break strict-aliasing rules" warnings

[project @ 2006-01-09 14:33:50 by simonmar]
Remove duplicate imports

[project @ 2006-01-09 14:33:21 by simonmar]
Remove dead panic

[project @ 2006-01-09 14:32:57 by simonmar]
Put a dummy record initialisation in to fix a warning

[project @ 2006-01-09 14:32:31 by simonmar]
Use correct format specifier for a size_t value

[project @ 2006-01-09 14:32:03 by simonmar]
Include string.h in unlit, fixing gcc "implicit declaration" warnings

[project @ 2006-01-09 14:31:37 by simonmar]
Include stdlib in lndir, fixing gcc "implicit declaration" warnings

[project @ 2006-01-09 14:25:44 by simonmar]

[project @ 2006-01-09 13:29:02 by simonmar]
Avoid desugaring bug in HEAD (see test ds057).

[project @ 2006-01-09 13:25:50 by simonmar]
Fix up to compile with GHC 5.04.x again.

Also includes a fix for a memory error I discovered along the way:
should fix the "scavenge_one" crash in the stage2 build of recent
HEADs.

[project @ 2006-01-09 10:31:14 by simonmar]
ord# and chr# should be no-ops, not conversions between wordRep and I32.

[project @ 2006-01-06 16:30:17 by simonmar]
Add support for UTF-8 source files

GHC finally has support for full Unicode in source files.  Source
files are now assumed to be UTF-8 encoded, and the full range of
Unicode characters can be used, with classifications recognised using
the implementation from Data.Char.  This incedentally means that only
the stage2 compiler will recognise Unicode in source files, because I
was too lazy to port the unicode classifier code into libcompat.

Additionally, the following synonyms for keywords are now recognised:

  forall symbol  (U+2200) forall
  right arrow    (U+2192) ->
  left arrow    (U+2190) <-
  horizontal ellipsis  (U+22EF) ..

there are probably more things we could add here.

This will break some source files if Latin-1 characters are being used.
In most cases this should result in a UTF-8 decoding error.  Later on
if we want to support more encodings (perhaps with a pragma to specify
the encoding), I plan to do it by recoding into UTF-8 before parsing.

Internally, there were some pretty big changes:

  - FastStrings are now stored in UTF-8

  - Z-encoding has been moved right to the back end.  Previously we
    used to Z-encode every identifier on the way in for simplicity,
    and only decode when we needed to show something to the user.
    Instead, we now keep every string in its UTF-8 encoding, and
    Z-encode right before printing it out.  To avoid Z-encoding the
    same string multiple times, the Z-encoding is cached inside the
    FastString the first time it is requested.

    This speeds up the compiler - I've measured some definite
    improvement in parsing at least, and I expect compilations overall
    to be faster too.  It also cleans up a lot of cruft from the
    OccName interface.  Z-encoding is nicely hidden inside the
    Outputable instance for Names & OccNames now.

  - StringBuffers are UTF-8 too, and are now represented as
    ForeignPtrs.

  - I've put together some test cases, not by any means exhaustive,
    but there are some interesting UTF-8 decoding error cases that
    aren't obvious.  Also, take a look at unicode001.hs for a demo.

[project @ 2006-01-06 11:04:07 by simonmar]
Document -Rghc-timing

[project @ 2006-01-05 13:10:55 by simonpj]
MERGE TO STABLE

This commit fixes a nasty problem discovered by Volker Stolz.
The problem is described in Note [Multiple instantiation] in
TcExpr, which is reproduced below.

(Core Lint identifies the problem, incidentally.)

tc200 is a test case.

Note [Multiple instantiation]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We are careful never to make a MethodInst that has, as its meth_id, another MethodInst.
For example, consider
f :: forall a. Eq a => forall b. Ord b => a -> b
At a call to f, at say [Int, Bool], it's tempting to translate the call to

f_m1
  where
f_m1 :: forall b. Ord b => Int -> b
f_m1 = f Int dEqInt

f_m2 :: Int -> Bool
f_m2 = f_m1 Bool dOrdBool

But notice that f_m2 has f_m1 as its meth_id.  Now the danger is that if we do
a tcSimplCheck with a Given f_mx :: f Int dEqInt, we may make a binding
f_m1 = f_mx
But it's entirely possible that f_m2 will continue to float out, because it
mentions no type variables.  Result, f_m1 isn't in scope.

Here's a concrete example that does this (test tc200):

    class C a where
      f :: Eq b => b -> a -> Int
      baz :: Eq a => Int -> a -> Int

    instance C Int where
      baz = f

Current solution: only do the "method sharing" thing for the first type/dict
application, not for the iterated ones.  A horribly subtle point.

[project @ 2006-01-05 10:02:58 by simonpj]
'newtype' declarations are now parsed exactly like data type declarations,
so that you can declare newtypes using GADT syntax.  But that means we
must check all the newtype restrictions separately, and I mised one.
This commit checks that there is no existential context on the newtype.

Test is tcfail156

[project @ 2006-01-05 09:42:54 by simonmar]
This file is not quite POSIX compliant; hopefully fix build on MacOS X
(Tiger)

[project @ 2006-01-04 12:51:59 by simonmar]
remove duplicate definition

[project @ 2006-01-04 12:49:38 by simonmar]
make 3.79.1 is ok

[project @ 2006-01-04 11:52:54 by simonpj]
Resolve ticket 644; crash when data con returns wrong type

[project @ 2006-01-03 16:15:37 by simonmar]
setContextAfterLoad: try to load a target if possible, otherwise load
the topmost module in the graph.  Previously we were loading the first
module in the list, which happened to be right a lot of the time, but
not always.

Fixes ticket #642