GitLab

Sebastian Graf pushed to branch wip/T25944 at Glasgow Haskell Compiler / GHC

Commits:

e2f2f9d0

by Vladislav Zavialov at 2025-04-20T10:53:39-04:00

Add name for -Wunusable-unpack-pragmas

This warning had no name or flag and was triggered unconditionally.
Now it is part of -Wdefault.

In GHC.Tc.TyCl.tcTyClGroupsPass's strict mode, we now have to
force-enable this warning to ensure that detection of flawed groups
continues to work even if the user disables the warning with the
-Wno-unusable-unpack-pragmas option. Test case: T3990c

Also, the misnamed BackpackUnpackAbstractType is now called
UnusableUnpackPragma.

6caa6508

by Adam Gundry at 2025-04-20T10:54:22-04:00

Fix specialisation of incoherent instances (fixes #25883)

GHC normally assumes that class constraints are canonical, meaning that
the specialiser is allowed to replace one dictionary argument with another
provided that they have the same type.  The `-fno-specialise-incoherents`
flag alters INCOHERENT instance definitions so that they will prevent
specialisation in some cases, by inserting `nospec`.

This commit fixes a bug in 7124e4ad76d98f1fc246ada4fd7bf64413ff2f2e, which
treated some INCOHERENT instance matches as if `-fno-specialise-incoherents`
was in effect, thereby unnecessarily preventing specialisation. In addition
it updates the relevant `Note [Rules for instance lookup]` and adds a new
`Note [Canonicity for incoherent matches]`.

0426fd6c
by Adam Gundry at 2025-04-20T10:54:23-04:00
```
Add regression test for #23429
```

eec96527

by Adam Gundry at 2025-04-20T10:54:23-04:00

user's guide: update specification of overlapping/incoherent instances

The description of the instance resolution algorithm in the user's
guide was slightly out of date, because it mentioned in-scope given
constraints only at the end, whereas the implementation checks for
their presence before any of the other steps.

This also adds a warning to the user's guide about the impact of
incoherent instances on specialisation, and more clearly documents
some of the other effects of `-XIncoherentInstances`.

a00eeaec

by Matthew Craven at 2025-04-20T10:55:03-04:00

Fix bytecode generation for `tagToEnum# <LITERAL>`

Fixes #25975.

2e204269

by Andreas Klebinger at 2025-04-22T12:20:41+02:00

Simplifier: Constant fold invald tagToEnum# calls to bottom expr.

When applying tagToEnum# to a out-of-range value it's best to simply
constant fold it to a bottom expression. That potentially allows more
dead code elimination and makes debugging easier.

Fixes #25976

7250fc0c

by Matthew Pickering at 2025-04-22T16:24:04-04:00

Move -fno-code note into Downsweep module

This note was left behind when all the code which referred to it was
moved into the GHC.Driver.Downsweep module

d2dc89b4

by Matthew Pickering at 2025-04-22T16:24:04-04:00

Apply editing notes to Note [-fno-code mode] suggested by sheaf

These notes were suggested in https://gitlab.haskell.org/ghc/ghc/-/merge_requests/14241

91564daf

by Matthew Pickering at 2025-04-24T00:29:02-04:00

ghci: Use loadInterfaceForModule rather than loadSrcInterface in mkTopLevEnv

loadSrcInterface takes a user given `ModuleName` and resolves it to the
module which needs to be loaded (taking into account module
renaming/visibility etc).

loadInterfaceForModule takes a specific module and loads it.

The modules in `ImpDeclSpec` have already been resolved to the actual
module to get the information from during renaming. Therefore we just
need to fetch the precise interface from disk (and not attempt to rename
it again).

Fixes #25951

2e0c07ab
by Simon Peyton Jones at 2025-04-24T00:29:43-04:00
```
Test for #23298
```

0eef99b0

by Sven Tennie at 2025-04-24T07:34:36-04:00

RV64: Introduce J instruction (non-local jumps) and don't deallocate stack slots for J_TBL (#25738)

J_TBL result in local jumps, there should not deallocate stack slots
(see Note [extra spill slots].)

J is for non-local jumps, these may need to deallocate stack slots.

1bd3d13e

by fendor at 2025-04-24T07:35:17-04:00

Add `UnitId` to `EvalBreakpoint`

The `EvalBreakpoint` is used to communicate that a breakpoint was
encountered during code evaluation.
This `EvalBreakpoint` needs to be converted to an `InternalBreakpointId`
which stores a `Module` to uniquely find the correct `Module` in the
Home Package Table.

The `EvalBreakpoint` used to store only a `ModuleName` which is then
converted to a `Module` based on the currently active home unit.
This is incorrect in the face of multiple home units, the break point
could be in an entirely other home unit!
To fix this, we additionally store the `UnitId` of the `Module` in
`EvalBreakpoint` to later reconstruct the correct `Module`

All of the changes are the consequence of extending `EvalBreakpoint`
with the additional `ShortByteString` of the `UnitId`.

For performance reasons, we store the `ShortByteString` backing the
`UnitId` directly, avoiding marshalling overhead.

fe6ed8d9

by Sylvain Henry at 2025-04-24T18:04:12-04:00

Doc: add doc for JS interruptible calling convention (#24444)

6111c5e4

by Ben Gamari at 2025-04-24T18:04:53-04:00

compiler: Ensure that Panic.Plain.assertPanic' provides callstack

In 36cddd2ce1a3bc62ea8a1307d8bc6006d54109cf @alt-romes removed CallStack
output from `GHC.Utils.Panic.Plain.assertPanic'`. While this output is
redundant due to the exception backtrace proposal, we may be
bootstrapping with a compiler which does not yet include this machinery.
Reintroduce the output for now.

Fixes #25898.

217caad1

by Matthew Pickering at 2025-04-25T18:58:42+01:00

Implement Explicit Level Imports for Template Haskell

This commit introduces the `ExplicitLevelImports` and
`ImplicitStagePersistence` language extensions as proposed in GHC
Proposal #682.

Key Features
------------

- `ExplicitLevelImports` adds two new import modifiers - `splice` and
`quote` - allowing precise control over the level at which imported
identifiers are available
- `ImplicitStagePersistence` (enabled by default) preserves existing
path-based cross-stage persistence behavior
- `NoImplicitStagePersistence` disables implicit cross-stage
persistence, requiring explicit level imports

Benefits
--------

- Improved compilation performance by reducing unnecessary code generation
- Enhanced IDE experience with faster feedback in `-fno-code` mode
- Better dependency tracking by distinguishing compile-time and runtime dependencies
- Foundation for future cross-compilation improvements

This implementation enables the separation of modules needed at
compile-time from those needed at runtime, allowing for more efficient
compilation pipelines and clearer code organization in projects using
Template Haskell.

Implementation Notes
--------------------

The level which a name is availble at is stored in the 'GRE', in the normal
GlobalRdrEnv. The function `greLevels` returns the levels which a specific GRE
is imported at. The level information for a 'Name' is computed by `getCurrentAndBindLevel`.
The level validity is checked by `checkCrossLevelLifting`.

Instances are checked by `checkWellLevelledDFun`, which computes the level an
instance by calling `checkWellLevelledInstanceWhat`, which sees what is
available at by looking at the module graph.

Modifications to downsweep
--------------------------

Code generation is now only enabled for modules which are needed at
compile time.
See the Note [-fno-code mode] for more information.

Uniform error messages for level errors
---------------------------------------

All error messages to do with levels are now reported uniformly using
the `TcRnBadlyStaged` constructor.

Error messages are uniformly reported in terms of levels.

0 - top-level
1 - quote level
-1 - splice level

The only level hard-coded into the compiler is the top-level in
GHC.Types.ThLevelIndex.topLevelIndex.

Uniformly refer to levels and stages
------------------------------------

There was much confusion about levels vs stages in the compiler.
A level is a semantic concept, used by the typechecker to ensure a
program can be evaluated in a well-staged manner.

A stage is an operational construct, program evaluation proceeds in
stages.

Deprecate -Wbadly-staged-types
------------------------------

`-Wbadly-staged-types` is deprecated in favour of `-Wbadly-levelled-types`.

Lift derivation changed
-----------------------

Derived lift instances will now not generate code with expression
quotations.

Before:

```
data A = A Int deriving Lift

=>
lift (A x) = [| A $(lift x) |]
```

After:

```
lift (A x) = conE 'A `appE` (lift x)
```

This is because if you attempt to derive `Lift` in a module where
`NoImplicitStagePersistence` is enabled, you would get an infinite loop
where a constructor was attempted to be persisted using the instance you
are currently defining.

GHC API Changes
---------------

The ModuleGraph now contains additional information about the type of
the edges (normal, quote or splice) between modules. This is abstracted
using the `ModuleGraphEdge` data type.

Fixes #25828

-------------------------
Metric Increase:
MultiLayerModulesTH_Make
-------------------------

7641a74a

by Simon Peyton Jones at 2025-04-26T22:05:19-04:00

Get a decent MatchContext for pattern synonym bindings

In particular when we have a pattern binding
    K p1 .. pn = rhs
where K is a pattern synonym.  (It might be nested.)

This small MR fixes #25995.  It's a tiny fix, to an error message,
removing an always-dubious `unkSkol`.

The bug report was in the context of horde-ad, a big program,
and I didn't manage to make a small repro case quickly. I decided
not to bother further.

ce616f49

by Simon Peyton Jones at 2025-04-27T21:10:25+01:00

Fix infelicities in the Specialiser

On the way to #23109 (unary classes) I discovered some infelicities
(or maybe tiny bugs, I forget) in the type-class specialiser.

I also tripped over #25965, an outright bug in the rule matcher

Specifically:

* Refactor: I enhanced `wantCallsFor`, whih previously always said
`True`, to discard calls of class-ops, data constructors etc.  This is
a bit more efficient; and it means we don't need to worry about
filtering them out later.

* Fix: I tidied up some tricky logic that eliminated redundant
  specialisations.  It wasn't working correctly.  See the expanded
  Note [Specialisations already covered], and
  (MP3) in Note [Specialising polymorphic dictionaries].

  See also the new top-level `alreadyCovered`
  function, which now goes via `GHC.Core.Rules.ruleLhsIsMoreSpecific`

  I also added a useful Note [The (CI-KEY) invariant]

* Fix #25965: fixed a tricky bug in the `go_fam_fam` in
  `GHC.Core.Unify.uVarOrFam`, which allows matching to succeed
  without binding all type varibles.

  I enhanced Note [Apartness and type families] some more

* #25703. This ticket "just works" with -fpolymorphic-specialisation;
  but I was surprised that it worked! In this MR I added documentation
  to Note [Interesting dictionary arguments] to explain; and tests to
  ensure it stays fixed.

22d11fa8

by Simon Peyton Jones at 2025-04-28T18:05:19-04:00

Track rewriter sets more accurately in constraint solving

The key change, which fixed #25440, is to call `recordRewriter` in
GHC.Tc.Solver.Rewrite.rewrite_exact_fam_app.  This missing call meant
that we were secretly rewriting a Wanted with a Wanted, but not really
noticing; and that led to a very bad error message, as you can see
in the ticket.

But of course that led me into rabbit hole of other refactoring around
the RewriteSet code:

* Improve Notes [Wanteds rewrite Wanteds]

* Zonk the RewriterSet in `zonkCtEvidence` rather than only in GHC.Tc.Errors.
  This is tidier anyway (e.g. de-clutters debug output), and helps with the
  next point.

* In GHC.Tc.Solver.Equality.inertsCanDischarge, don't replace a constraint
  with no rewriters with an equal constraint that has many. See
  See (CE4) in Note [Combining equalities]

* Move zonkRewriterSet and friends from GHC.Tc.Zonk.Type into
  GHC.Tc.Zonk.TcType, where they properly belong.

A handful of tests get better error messages.

For some reason T24984 gets 12% less compiler allocation -- good

Metric Decrease:
    T24984

6467d61e

by Brandon Chinn at 2025-04-29T18:36:03-04:00

Fix lexing "\^\" (#25937)

This broke in the refactor in !13128, where the old code parsed escape
codes and collapsed string gaps at the same time, but the new code
collapsed gaps first, then resolved escape codes. The new code used a
naive heuristic to skip escaped backslashes, but didn't account for
"\^\".

99868a86
by Jens Petersen at 2025-04-29T18:36:44-04:00
```
hadrian: default selftest to disabled
```

aba2a4a5

by Zubin Duggal at 2025-04-30T06:35:59-04:00

get-win32-tarballs.py: List tarball files to be downloaded if we cannot find them

Fixes #25929

d99a617b

by Ben Gamari at 2025-04-30T06:36:40-04:00

Move Data ModuleName instance to Language.Haskell.Syntax.Module.Name

Fixes #25968.

9995c2b7

by Serge S. Gulin at 2025-05-04T17:13:36+03:00

Support for ARM64 Windows (LLVM-enabled) (fixes #24603)

1. Add Windows AArch64 cross-compilation support via CI jobs
Introduce new CI configurations for cross-compiling to Windows ARM64 using Debian12Wine, FEX, and MSYS2.
Configure toolchain variables for LLVM MinGW and Wine emulation in CI pipelines.

2. Adjust compiler and RTS for AArch64 Windows compatibility
Reserve register `x18` on Windows and Darwin platforms in AArch64 codegen.
Handle Windows-specific relocations and data sections in AArch64 assembler.
Update PEi386 linker to recognize ARM64 binaries and support exception handling.
Adjust LLVM target definitions and data layouts for new architectures.
Update `ghc-toolchain` and build scripts to handle `TablesNextToCode` on Windows ARM64.

3. Enhance CI scripts and stability
Modify `ci.sh` to handle mingw cross-targets, fixing GHC executable paths and test execution.
Use `diff -w` in tests to ignore whitespace differences, improving cross-platform consistency.

4. Refactor and clean up code
Remove redundant imports in hello.hs test.
Improve error messages and checks for unsupported configurations in the driver.
Add `EXDEV` error code to `errno.js`.
Add async/sync flags to IO logs at `base.js`.
Improve POSIX compatibility for file close at `base.js`: decrease indeterminism for mixed cases of async and sync code.

5. Update dependencies: `Cabal`, `Win32`, `directory`, `process`, `haskeline`, and `unix`.

submodule

Co-authored-by: Cheng Shao <terrorjack@type.dance>
Co-authored-by: Dmitrii Egorov <egorov.d.i@icloud.com>
Co-authored-by: Andrei Borzenkov <root@sandwitch.dev>

50fa8165

by Javran Cheng at 2025-05-05T05:55:39-04:00

Suppress unused do-binding if discarded variable is Any or ZonkAny.

Consider example (#25895):

>  do { forever (return ()); blah }

where `forever :: forall a b. IO a -> IO b`.

Nothing constrains `b`, so it will be instantiates with `Any` or
`ZonkAny`.
But we certainly don't want to complain about a discarded do-binding.

Fixes #25895

e46c6b18

by Rodrigo Mesquita at 2025-05-06T09:01:57-04:00

Refactor mkTopLevImportedEnv out of mkTopLevEnv

This makes the code clearer and allows the top-level import context to
be fetched directly from the HomeModInfo through the API (e.g. useful
for the debugger).

0ce0d263

by Rodrigo Mesquita at 2025-05-06T09:01:57-04:00

Export sizeOccEnv from GHC.Types.Name.Occurrence

Counts the number of OccNames in an OccEnv

165f98d8

by Simon Peyton Jones at 2025-05-06T09:02:39-04:00

Fix a bad untouchability bug im simplifyInfer

This patch addresses #26004.  The root cause was that simplifyInfer
was willing to unify variables "far out".  The fix, in
runTcSWithEvBinds', is to initialise the inert set given-eq level with
the current level. See
    (TGE6) in Note [Tracking Given equalities]
in GHC.Tc.Solver.InertSet

Two loosely related refactors:

* Refactored approximateWCX to return just the free type
  variables of the un-quantified constraints.  That avoids duplication
  of work (these free vars are needed in simplifyInfer) and makes it
  clearer that the constraints themselves are irrelevant.

* A little local refactor of TcSMode, which reduces the number of
  parameters to runTcSWithEvBinds

6e67fa08

by Ben Gamari at 2025-05-08T06:21:21-04:00

llvmGen: Fix built-in variable predicate

Previously the predicate to identify LLVM builtin global variables was
checking for `$llvm` rather than `@llvm` as it should.

a9d0a22c

by Ben Gamari at 2025-05-08T06:21:22-04:00

llvmGen: Fix linkage of built-in arrays

LLVM now insists that built-in arrays use Appending linkage, not
Internal.

Fixes #25769.

9c6d2b1b

by sheaf at 2025-05-08T06:22:11-04:00

Use mkTrAppChecked in ds_ev_typeable

This change avoids violating the invariant of mkTrApp according to which
the argument should not be a fully saturated function type.
This ensures we don't return false negatives for type equality
involving function types.

Fixes #25998

75cadf81

by Ryan Hendrickson at 2025-05-08T06:22:55-04:00

haddock: Preserve indentation in multiline examples

Intended for use with :{ :}, but doesn't look for those characters. Any
consecutive lines with birdtracks will only have initial whitespace
stripped up to the column of the first line.

fee9b351

by Cheng Shao at 2025-05-08T06:23:36-04:00

ci: re-enable chrome for wasm ghci browser tests

Currently only firefox is enabled for wasm ghci browser tests, for
some reason testing with chrome works on my machine but gets stuck on
gitlab instance runners. This patch re-enables testing with chrome by
passing `--no-sandbox`, since chrome sandboxing doesn't work in
containers without `--cap-add=SYS_ADMIN`.

282df905

by Vladislav Zavialov at 2025-05-09T03:18:25-04:00

Take subordinate 'type' specifiers into account

This patch fixes multiple bugs (#22581, #25983, #25984, #25991)
in name resolution of subordinate import lists.

Bug #22581
----------
In subordinate import lists, the use of the `type` namespace specifier
used to be ignored. For example, this import statement was incorrectly
accepted:

  import Prelude (Bool(type True))

Now it results in an error message:

  <interactive>:2:17: error: [GHC-51433]
    In the import of ‘Prelude’:
      a data type called ‘Bool’ is exported,
      but its subordinate item ‘True’ is not in the type namespace.

Bug #25983
----------
In subordinate import lists within a `hiding` clause, non-existent
items led to a poor warning message with -Wdodgy-imports. Consider:

  import Prelude hiding (Bool(X))

The warning message for this import statement used to misreport the
cause of the problem:

  <interactive>:3:24: warning: [GHC-56449] [-Wdodgy-imports]
    In the import of ‘Prelude’:
      an item called ‘Bool’ is exported, but it is a type.

Now the warning message is correct:

  <interactive>:2:24: warning: [GHC-10237] [-Wdodgy-imports]
    In the import of ‘Prelude’:
      a data type called ‘Bool’ is exported, but it does not export
      any constructors or record fields called ‘X’.

Bug #25984
----------
In subordinate import lists within a `hiding` clause, non-existent
items resulted in the entire import declaration being discarded.
For example, this program was incorrectly accepted:

  import Prelude hiding (Bool(True,X))
  t = True

Now it results in an error message:

  <interactive>:2:5: error: [GHC-88464]
    Data constructor not in scope: True

Bug #25991
----------
In subordinate import lists, it was not possible to refer to a class
method if there was an associated type of the same name:

  module M_helper where
    class C a b where
      type a # b
      (#) :: a -> b -> ()

  module M where
    import M_helper (C((#)))

This import declaration failed with:

  M.hs:2:28: error: [GHC-10237]
    In the import of ‘M_helper’:
      an item called ‘C’ is exported, but it does not export any children
      (constructors, class methods or field names) called ‘#’.

Now it is accepted.

Summary
-------
The changes required to fix these bugs are almost entirely confined to
GHC.Rename.Names. Other than that, there is a new error constructor
BadImportNonTypeSubordinates with error code [GHC-51433].

Test cases:
  T22581a T22581b T22581c T22581d
  T25983a T25983b T25983c T25983d T25983e T25983f T25983g
  T25984a T25984b
  T25991a T25991b1 T25991b2

51b0ce8f

by Simon Peyton Jones at 2025-05-09T03:19:07-04:00

Slighty improve `dropMisleading`

Fix #26105, by upgrading the (horrible, hacky) `dropMisleading`
function.

This fix makes things a bit better but does not cure the underlying
problem.

7b2d1e6d

by Simon Peyton Jones at 2025-05-11T03:24:47-04:00

Refine `noGivenNewtypeReprEqs` to account for quantified constraints

This little MR fixes #26020.  We are on the edge of completeness
for newtype equalities (that doesn't change) but this MR makes GHC
a bit more consistent -- and fixes the bug reported.

eaa8093b

by Cheng Shao at 2025-05-11T03:25:28-04:00

wasm: mark freeJSVal as INLINE

This patch marks `freeJSVal` as `INLINE` for the wasm backend. I
noticed that the `freeJSVal` invocations are not inlined when
inspecting STG/Cmm dumps of downstream libraries that use release
build of the wasm backend. The performance benefit of inlining here is
very modest, but so is the cost anyway; if you are using `freeJSVal`
at all then you care about every potential chance to improve
performance :)

eac196df

by Cheng Shao at 2025-05-11T03:25:28-04:00

wasm: add zero length fast path for fromJSString

This patch adds a zero length fast path for `fromJSString`; when
marshaling a zero-length `JSString` we don't need to allocate an empty
`ByteArray#` at all.

652cba7e

by Peng Fan at 2025-05-14T04:24:35-04:00

Add LoongArch NCG support

Not supported before.

c01f4374

by Lin Runze at 2025-05-14T04:24:35-04:00

ci: Add LoongArch64 cross-compile CI for testing

ce6cf240

by Ben Gamari at 2025-05-14T04:25:18-04:00

rts/linker: Don't fail due to RTLD_NOW

In !12264 we started using the NativeObj machinery introduced some time
ago for loading of shared objects. One of the side-effects of this
change is shared objects are now loaded eagerly (i.e. with `RTLD_NOW`).
This is needed by NativeObj to ensure full visibility of the mappings of
the loaded object, which is in turn needed for safe shared object
unloading.

Unfortunately, this change subtly regressed, causing compilation
failures in some programs. Specifically, shared objects which refer to
undefined symbols (e.g. which may be usually provided by either the
executable image or libraries loaded via `dlopen`) will fail to load
with eager binding. This is problematic as GHC loads all package
dependencies while, e.g., evaluating TemplateHaskell splices. This
results in compilation failures in programs depending upon (but not
using at compile-time) packages with undefined symbol references.

To mitigate this NativeObj now first attempts to load an object via
eager binding, reverting to lazy binding (and disabling unloading) on
failure.

See Note [Don't fail due to RTLD_NOW].

Fixes #25943.

88ee8bb5

by Sylvain Henry at 2025-05-14T04:26:15-04:00

Deprecate GHC.JS.Prim.Internal.Build (#23432)

Deprecated as per CLC proposal 329 (https://github.com/haskell/core-libraries-committee/issues/329)

b4ed465b

by Cheng Shao at 2025-05-14T04:26:57-04:00

libffi: update to 3.4.8

Bumps libffi submodule.

a3e71296
by Matthew Pickering at 2025-05-14T04:27:38-04:00
```
Remove leftover trace
```

2d0ecdc6

by Cheng Shao at 2025-05-14T04:28:19-04:00

Revert "ci: re-enable chrome for wasm ghci browser tests"

This reverts commit fee9b351fa5a35d5778d1252789eacaaf5663ae8.
Unfortunately the chrome test jobs may still timeout on certain
runners (e.g. OpenCape) for unknown reasons.

3b3a5dec

by Ben Gamari at 2025-05-15T16:10:01-04:00

Don't emit unprintable characters when printing Uniques

When faced with an unprintable tag we now instead print the codepoint
number.

Fixes #25989.

(cherry picked from commit e832b1fadee66e8d6dd7b019368974756f8f8c46)

e1ef8974

by Mike Pilgrem at 2025-05-16T16:09:14-04:00

Translate iff in Haddock documentation into everyday English

fd64667d

by Vladislav Zavialov at 2025-05-20T03:25:08-04:00

Allow the 'data' keyword in import/export lists (#25899)

This patch introduces the 'data' namespace specifier in import and
export lists. The intended use is to import data constructors without
their parent type constructors, e.g.

  import Data.Proxy as D (data Proxy)
  type DP = D.Proxy   -- promoted data constructor

Additionally, it is possible to use 'data' to explicitly qualify any
data constructors or terms, incl. operators and field selectors

  import Prelude (Semigroup(data (<>)))
  import Data.Function (data (&))
  import Data.Monoid (data Dual, data getDual)

  x = Dual "Hello" <> Dual "World" & getDual

The implementation mostly builds on top of the existing logic for the
'type' and 'pattern' namespace specifiers, plus there are a few tweaks
to how we generate suggestions in error messages.

acc86753

by Ben Gamari at 2025-05-20T03:25:51-04:00

compiler: Use field selectors when creating BCOs

This makes it easier to grep for these fields.

60a55fd7

by Ben Gamari at 2025-05-20T03:25:51-04:00

compiler: Clarify BCO size

Previously the semantics and size of StgBCO was a bit unclear.
Specifically, the `size` field was documented to contain the size of the
bitmap whereas it was actually the size of the closure *and* bitmap.
Additionally, it was not as clear as it could be that the bitmap was a
full StgLargeBitmap with its own `size` field.

ac9fb269

by Simon Peyton Jones at 2025-05-20T09:19:04-04:00

Track rewriter sets more accurately in constraint solving

This MR addresses #26003, by refactoring the arcane
intricacies of Note [Equalities with incompatible kinds].
NB: now retitled to
    Note [Equalities with heterogeneous kinds].
and the main Note for this MR.

In particular:

* Abandon invariant (COERCION-HOLE) in Note [Unification preconditions] in
  GHC.Tc.Utils.Unify.

* Abandon invariant (TyEq:CH)) in Note [Canonical equalities] in
  GHC.Tc.Types.Constraint.

* Instead: add invariant (REWRITERS) to Note [Unification preconditions]:
  unify only if the constraint has an empty rewriter set.

Implementation:

* In canEqCanLHSFinish_try_unification, skip trying unification if there is a
  non-empty rewriter set.

* To do this, make sure the rewriter set is zonked; do so in selectNextWorkItem,
  which also deals with prioritisation.

* When a coercion hole is filled, kick out inert equalities that have that hole
  as a rewriter.  It might now be unlocked and available to unify.

* Remove the ad-hoc `ch_hetero_kind` field of `CoercionHole`.

* In `selectNextWorkItem`, priorities equalities withan empty rewriter set.

* Defaulting: see (DE6) in Note [Defaulting equalities]
  and Note [Limited defaulting in the ambiguity check]

* Concreteness checks: there is some extra faff to try to get decent
  error messages when the FRR (representation-polymorphism) checks
  fail. In partiular, add a "When unifying..." explanation when the
  representation-polymorphism check arose from another constraint.

86406f48

by Cheng Shao at 2025-05-20T09:19:47-04:00

rts: fix rts_clearMemory logic when sanity checks are enabled

This commit fixes an RTS assertion failure when invoking
rts_clearMemory with +RTS -DS. -DS implies -DZ which asserts that free
blocks contain 0xaa as the designated garbage value. Also adds the
sanity way to rts_clearMemory test to prevent future regression.
Closes #26011.

ChatGPT Codex automatically diagnosed the issue and proposed the
initial patch in a single shot, given a GHC checkout and the following
prompt:

---

Someone is reporting the following error when attempting to use `rts_clearMemory` with the RTS option `-DS`:

```
test.wasm: internal error: ASSERTION FAILED: file rts/sm/Storage.c, line 1216

    (GHC version 9.12.2.20250327 for wasm32_unknown_wasi)
    Please report this as a GHC bug:  https://www.haskell.org/ghc/reportabug
```

What's the culprit? How do I look into this issue?

---

I manually reviewed & revised the patch, tested and submitted it.

7147370b