GitLab

Alan Zimmerman pushed to branch wip/az/exactprint-annotation-rationalisation at Glasgow Haskell Compiler / GHC

Commits:

7a108e43

by Simon Jakobi at 2026-09-12T18:35:59-04:00

FastString: Drop mkFastStringWith's constructor callback

All three callers passed the same callback, a partial application of
mkNewFastStringShortByteString to the string being interned. That
partial application is allocated as a closure before the table lookup,
on the common hit path too, although the callback is needed only after
a miss.

Drop the parameter and call mkNewFastStringShortByteString directly
after a miss. Since nothing is passed "with" anymore, rename the
function to internSB.

Suggested by Simon PJ in #27528:
https://gitlab.haskell.org/ghc/ghc/-/work_items/27528#note_687031

Assisted-by: Claude Fable 5

82c73b22

by Alan Zimmerman at 2026-09-12T18:36:38-04:00

EPA: More targeted HsDo exact print annotation

HsDo is multi-purpose, as encoded in its HsDoFlavour field. Some of
these are in a layout context (DoExpr, MDoExpr), others are not
(ListComp, MonadComp).

We are moving towards using AnnList only in layout contexts, so we
switch the HsDo TTG annotation from holding an AnnList for this, to
holding

  Either (EpToken "[", EpToken "]") AnnList

This also allows us to trim down AnnListBrackets to only have braces
or None, thereby opening the door for unification with the existing
layout context data type EpLayout.

749d2448

by Luite Stegeman at 2026-09-15T14:07:01-04:00

rts: handle large CONSTR closures in compacting GC

The function update_fwd_large in the compacting GC could run into
an unexpected object with the following error:

  internal error: update_fwd_large: unknown/strange object  1

Closure type 1 is CONSTR. This patch adds cases for CONSTR and
CONSTR_NOCAF.

This is the same problem as #27434 (large AP closures, fixed by
cca0d58963), which missed this case.

Fixes #27649

177d6155

by Luite Stegeman at 2026-09-15T14:07:02-04:00

testsuite: fix T27434 test with compacting GC

Ensure that the interpreter is actually run with the compacting GC

5796aa63

by Luite Stegeman at 2026-09-15T14:07:49-04:00

rts: initialise the stack frame header for mask_frame and apply_mask_frame

We must leave the stack in consistent state before jumping to
mask_frame or apply_mask_frame because they may result. Failing
to do so could lead to a crash if there were waiting exceptions.

Fixes #27651

2486cc92

by Simon Peyton Jones at 2026-09-15T14:08:36-04:00

Re-introduce the "weird SpecDict" case

In this commit

    commit f80375dd4945350a1d784e436975b48b9c736eaf
    Author: Simon Peyton Jones <simon.peytonjones@gmail.com>
    Date:   Sun Jun 29 15:26:58 2025 +0100

      Refactor of Specialise.hs

I removed a test for a dictionary with unbound type variables.  This
turned out to be wrong; see #27629.

So this MR re-introduces it.

8e09a46f

by Duncan Coutts at 2026-09-15T20:11:35-04:00

Refactor (and rename) removeFromQueues, to simplify I/O managers

Rename it to unblockAndAppendToRunQueue which better reflects what it is
intended to do.

The post-condition for unblockAndAppendToRunQueue is that the TSO is on
the run queue or it is in the process of migrating to another cap.
Previously it achieved that by always directly adding the TSO to the run
queue itself.

But this actually made things more complicated for the I/O managers,
because it meant they needed a separate code path for notifying for
cancellation compared to notifying for completion. The general
notification code would always add the TSO to the run queue itself.

So the improvement is to allow different cases in
unblockAndAppendToRunQueue to achieve the same outcome in different
ways: either directly adding to the run queue or calling helper
functions that do so themselves.

This then allows the new I/O managers to share code between the sync and
async cancellation, and to reuse their notifyIOCompletion helpers for
cancellation. This avoids a source of bugs where the completion path may
be updated but the cancellation path may be forgotten, or similarly in
future for sync/async operations.

Update all the existing in-RTS I/O managers, and the posix timeout code.

d668782c

by Duncan Coutts at 2026-09-15T20:11:35-04:00

Document that awaitCompletedTimeoutsOrIO expects an empty run queue

This was true before but implicit and not relied on much. It's better to
be explicit, and allow things to depend on it.

11d938bb

by Duncan Coutts at 2026-09-15T20:11:35-04:00

Store the I/O opcode and fd in the StgAsyncIOOp

This will be useful in several I/O managers and it is handy for logging
and debugging.

It also doesn't increase the size of the StgAsyncIOOp structure. There
was enough spare padding space already.

Update the poll I/O manager to set the new fields.

Add a helper function to convert the enum IOReadOrWrite into the enum
IOOpCode. Also change IOReadOrWrite to be an enum without a typedef, for
consistency with other enumerations in IOManager.h

bfa87882

by Duncan Coutts at 2026-09-15T20:11:36-04:00

Add a new I/O manager based on select()

Yes, this is the second such I/O manager, but it is a modern
re-implementation based on the new in-RTS I/O manager infrastructure. So
it is cleaner and faster than the old select I/O manager.

Why do we need another I/O manager based on select? Why isn't the poll()
one good enough as a baseline portable unix I/O manager? Because macOS.
Apple Inc. is why we cannot have nice things.

The man page for poll on macOS documents the fact that it does not work.
At least, it does not work for all files. Specifically, it does not work
for device files. Whereas macOS select() does work for device files.
Aaaaarg!

We _do_ want to deprecate and remove the old select I/O manager, but due to
macOS we cannot do that until we have a replacement. This is that
replacement. Until of course a nice new k-queue I/O manager arrives,
which could become the new default for macOS and FreeBSD.

Interestingly, this select I/O manager is actually faster than the poll
one, on Linix, in some circumstances: specifically when many Haskell
threads are waiting on the same fd. The poll I/O manager does O(n) work
for n threads waiting on I/O, whereas the select one does O(fds) work
for the number of fds that threads are waiting on. Usually this is 1:1,
so it's not noticable, but one can concoct extreme benchmarks to show
the difference.

8e9de15a

by Duncan Coutts at 2026-09-15T20:11:36-04:00

Minor updates in the poll I/O manager to keep in sync with select

This keeps it in sync with select one. The changes are based on code review
while implementing the new select I/O manager. The two I/O managers are so
similar in structure that it makes sense to try to minimise the diff between
them. This should aid understanding, and fixes to both in future.

222668bb

by Duncan Coutts at 2026-09-15T20:11:36-04:00

Document the new select I/O manager in the user guide

in the RTS section about I/O managers.

And add a changelog entry.

0f48735b

by Cheng Shao at 2026-09-15T20:12:23-04:00

Revert "wasm: workaround WebKit bug in dyld"

This reverts commit c9b8465c2c338176fcab9d197e9d31f4aee11f68. The
underlying webkit bug has been fixed in
https://commits.webkit.org/314219@main. Closes #27564.

809294f1

by Luite Stegeman at 2026-09-15T20:13:08-04:00

rts: make stg_threadLabelzh return a valid pointer for unlabeled threads.

This fixes a segfault in the GC caused by stg_threadLabelzh returning
a 0 pointer in a GC pointer field.

stg_threadLabelzh returns a tuple of type (# Int#, ByteArray# #). If a
thread has no label, the second field is unused. We must still return
a valid heap object pointer.

Instead of returning 0, we now return stg_DEAD_SLOT_closure.

fixes #27618

e2d57026

by Luite Stegeman at 2026-09-15T20:13:54-04:00

JS: fix selector thunk handling

fix a bug where entering a selector thunk could lead to a crash
if the selected field was still a thunk.

fixes #27788

1b4a622f

by sheaf at 2026-09-17T02:39:13-04:00

Improvements to type/data family handling

This commit makes several improvements to the treatment of type and data
families in GHC:

  - We consistently use "type family" instead of "type synonym family"
    to avoid a confusion with type synonyms. For example:

      - OpenSynFamilyTyCon ==> OpenTypeFamilyTyCon
      - ClosedSynFamilyTyCon => ClosedTypeFamilyTyCon

  - Various functions that were specific to data families have been
    renamed to make this clear. For example:

      - tyConFamInst_maybe ==> tyConDataFamInst_maybe
      - isFamInstTyCon ==> isDataFamInstTyCon

  - 'FamTyConFlav' has been refactored so that all closed type families
    share a single 'ClosedTypeFamilyTyCon' constructor.
    The corresponding 'IfaceFamTyConFlav' type was updated similarly.

    This is then used to tidy up the implementation of
    GHC.Core.FamInstEnv.reduceTyFamApp_maybe.

c5aa9098

by sheaf at 2026-09-17T02:39:13-04:00

Small refactor of lookupFamInstEnv

This commit reworks the code for looking up family instances in
GHC.Core.FamInstEnv, reducing duplication a little bit.

No change in behaviour.

a3ad4588

by sheaf at 2026-09-17T02:39:14-04:00

Use a type family for boxing unboxed types

This commit overhauls the way in which unboxed types are boxed, as per
the updated Note [Boxing constructors] in GHC.Builtin.WiredIn.Types.Box.

The main change is to allow boxing to be parametrised by representation,
e.g. making 'Box ty' a valid type. We achieve this by implementing 'Box'
using a closed type family:

  newtype Box (a :: TYPE r) = Box (BoxTF r)

  type BoxTF :: RuntimeRep -> Type
  type family BoxTF r where
    BoxTF IntRep    = BoxInt
    BoxTF Int8Rep   = BoxInt8
    BoxTF WordRep   = BoxWord
    BoxTF LiftedRep = Any @Type
    BoxTF (TupleRep [r1, r2]) = (BoxTF r1, BoxTF r2)
    ...
    BoxTF (SumRep rs) = BoxSum rs

This new design solves the following problems:

  - It allows boxing a type whose 'RuntimeRep' has not yet been
    determined (e.g. because we only learn the 'RuntimeRep' after
    constraint solving). That is, 'Box @r a' is a perfectly valid type
    even if 'r' is an unfilled metavariable. This is a requirement
    to fix #25065 (in which we need to box a type whose 'RuntimeRep'
    is only filled in during constraint solving).

  - It handles boxing of unboxed tuples and unboxed sums, via recursive
    boxing. See Note [Boxing TupleRep and SumRep] in
    GHC.Builtin.WiredIn.Types.Box.

'Box', 'BoxTF' and all of the boxing data constructors are defined in
a new 'ghc-internal' module, 'GHC.Internal.Box'. This module contains
nothing but wired-in declarations, and GHC never loads its interface on
account of a wired-in thing (GHC.Builtin.Modules.isWiredInOnlyModule);
see Note [Loading instances for wired-in things] in GHC.Iface.Load.

The individual boxing data constructors are deliberately left as an
internal implementation detail, and not exported. The intended API is
via the two new magic 'Id's:

  box :: forall {r} (a :: TYPE r). a -> Box a
  unbox :: forall {r} (a :: TYPE r). Box a -> a

exported from 'GHC.PrimOps' (in 'ghc-experimental'). The old boxing
data types (IntBox, WordBox, FloatBox, DoubleBox, DictBox) are no longer
exported from base (CLC proposal #421).

We use this new design to consistently desugar:

  - parallel comprehensions (GHC.HsToCore.ListComp.{deListComp,dsMcStmt})
  - then/group/using statements (GHC.HsToCore.ListComp.{dsTransStmt,dsMcStmt})
  - recursive do blocks (mdo/rec) (GHC.HsToCore.Expr.dsDo)
  - arrows (GHC.HsToCore.Arrows)

by consistently using 'box'/'unbox' to deal with unboxed types being put
into big tuples. We also adapt 'GHC.Tc.Gen.Match.{tcMcStmt,tcDoStmt}'
to create fresh /representation-polymorphic/ type variables for the
binders that we are going to put into a big tuple (previously, GHC only
allowed lifted types in that position).

These desugaring of box and unbox is explained in
Note [Desugaring box & unbox] in GHC.Core.Make.Box. Roughly speaking,
the desugaring looks like:

  box   @r @ty e  ==>  K e
  unbox @r @ty e  ==>  case e of K x -> x

where 'K' is the boxing data constructor at RuntimeRep 'r'. It's
slightly more complicated than that in practice: we first need to
insert a cast (see Note [The canonical type of a RuntimeRep]) using the
new 'CanonicalProv' 'UnivCoProvenance', and unboxed tuples/sums need
recursive logic explained in Note [box/unbox for unboxed tuples and sums],
including a specific 'BoxSum' datatypes for unboxed sum (which also
needed a wired-in type-level list indexing type family (!!)).

The desugaring happens in two ways:

  - Occurrences of 'box'/'unbox' emitted by the typechecker are
    eliminated in the 'ds_app_var' case of GHC.HsToCore.Expr.

  - Other code that needs to box/unbox emits the appropriate code inline.
    This includes the big tuple machinery of GHC.Core.Make used by the
    desugarer (GHC.HsToCore.{Utils,Binds,Arrows,ListComp}) as well as
    the float-out pass (GHC.Core.Opt.SetLevels).

Core Lint checks that no occurrence of 'box'/'unbox' survives desugaring.

On the way, we overhaul the litany of big tuple functions by introducing

  data BigTupleLayout = BoxedElements | BareElements

to distinguish the two kinds of "big tuples" that GHC routinely deals
with; for example 'mkBigCoreVarTupSolo' becomes 'mkBigCoreVarTup BareElements'.
All of this code is moved to the new module GHC.Core.Make.BigTuple.

Fixes #20864 #22336 #22473 #25065 #27331

-------------------------
Metric Decrease:
    T9872a
-------------------------

4cf7628a

by Evgeny Malyshev at 2026-09-17T02:39:56-04:00

Fix the CompactionFailed documentation link to compact

The old Haddock reference links into base instead of ghc-compact.
Use an explicit URL because ghc-compact depends on base, not vice versa.

Fixes #27558

Assisted-By: OpenAI Codex

098bba70

by Facundo Domínguez at 2026-09-17T14:57:41-04:00

Remove the call to hoistFlag from processCmdLineP

This call was undesirable because it was causing a reconstruction
of the list of flag processors.

Even relying on list fusion would not be sufficient because we want
to replace the list with a data structure with faster lookups to
address #25763.

The removal is done in two moves:

* We move CmdLineP to CmdLine.hs
* Then we move the effect of hoisting to processArgs via a new function
  hoistEwM

e01799c7

by Facundo Domínguez at 2026-09-17T14:57:42-04:00

Do not create duplicate flag processors for the -W flag

This makes simpler implementing the command line parser with a trie map
holding flag processors. If we were to allow duplicate flag processors
for any flag, the trie map would need to be a multimap.

3875b257

by Facundo Domínguez at 2026-09-17T14:57:42-04:00

Replace the list of flag processors with a trie map in `processArgs`

Previously `GHC.Driver.CmdLine.findArg` was called for each
command-line argument, doing a linear search on the list of flag
processors each time. This was somewhat costly as the list of flag
processor has near 2000 elements.

A lookup with a trie map is faster in general, but the speed up is
only noticeable when calling `GHC.Driver.CmdLine.processArgs` sufficient
times, so the amount of lookups piles up. This could happen in large
projects with many units each having many dependencies. If only a
module needs to be recompiled, the user still needs to wait for all of
the flag parsing to complete.

The benchmark at testsuite/tests/perf/compiler/cmdline-parser shows a
10x speed up when using the trie.

The trie map is implemented in `GHC.Data.StringTrie`.

The design is explained in Note [Processing command line argument fast]
in GHC.Driver.Session.

The commit also:
* adds two property-based tests for trie map operations,
* adds a benchmark of the command line parser, and
* renames the predicate `arg_ok` to `valid_flag_suffix` to decide what
  flag processor should be used when there are multiple matching
  prefixes on a flag.

Fixes #25763.

5236634a

by Andreas Klebinger at 2026-09-17T14:58:24-04:00

Compile Word64{Map,Set} with -O2 always.

This is the hottest code and even if we build GHC with -O0 otherwise -O2
pays off for these modules.

Fixes #27814.

7c93b793

by Alan Zimmerman at 2026-09-20T18:28:24+01:00

EPA: Add specific layout field to AnnList

Up to now AnnList has effectively served to represent lists of things
having layout, regardless of whether they do or not.

In Haskell, layout is optional in many places, as there is also an
alternative syntax using braces and semi-colons, which is free-form.

This commit introduces AnnListLayout, a data structure capturing this
distinction.

It is deliberately set up similarly to EpLayout, so that these two can
be merged in time.

d268c6d1

by Alan Zimmerman at 2026-09-20T18:28:24+01:00

EPA: Use EpaLocation in EpVirtualBraces

reword:
EPA Use vocurly as basis for AnnListLayout

For the existing cases that populate AnnList.

This also shows up AnnList usages that can never capture layout.

9e35bd08

by Alan Zimmerman at 2026-09-20T18:28:24+01:00

EPA: Use vocurly as basis for AnnListLayout

For the existing cases that populate AnnList.

This also shows up AnnList usages that can never capture layout.

80b4d2c0
by Alan Zimmerman at 2026-09-20T18:28:24+01:00
```
EPA: AnnList clean up patch for empty where clause
```

21bac229

by Alan Zimmerman at 2026-09-20T19:14:58+01:00

EPA: Add TTG fields to FamilyInfo

This commit is a simple add, with unused extension fields.

It lays the groundwork for using them for exact print annotations

06e028a0
by Alan Zimmerman at 2026-09-20T20:52:22+01:00
```
WIP annclassdecl
```

f34f809d