GitLab

Apoorv Ingle pushed to branch wip/spj-apporv-Oct24 at Glasgow Haskell Compiler / GHC

Commits:

8b731e3c

by Matthew Pickering at 2025-07-21T13:36:43-04:00

level imports: Fix infinite loop with cyclic module imports

I didn't anticipate that downsweep would run before we checked for
cyclic imports. Therefore we need to use the reachability function which
handles cyclic graphs.

Fixes #26087

d751a9f1
by Pierre Thierry at 2025-07-21T13:37:28-04:00
```
Fix documentation about deriving from generics
```

f8d9d016

by Andrew Lelechenko at 2025-07-22T21:13:28-04:00

Fix issues with toRational for types capable to represent infinite and not-a-number values

This commit fixes all of the following pitfalls:

> toRational (read "Infinity" :: Double)
179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216 % 1
> toRational (read "NaN" :: Double)
269653970229347386159395778618353710042696546841345985910145121736599013708251444699062715983611304031680170819807090036488184653221624933739271145959211186566651840137298227914453329401869141179179624428127508653257226023513694322210869665811240855745025766026879447359920868907719574457253034494436336205824 % 1

> realToFrac (read "NaN" :: Double) -- With -O0
Infinity
> realToFrac (read "NaN" :: Double) -- With -O1
NaN

> realToFrac (read "NaN" :: Double) :: CDouble
Infinity
> realToFrac (read "NaN" :: CDouble) :: Double
Infinity

Implements https://github.com/haskell/core-libraries-committee/issues/338

5dabc718

by Zubin Duggal at 2025-07-22T21:14:10-04:00

haddock: Don't warn about missing link destinations for derived names.

Fixes #26114

9c3a0937

by Matthew Pickering at 2025-07-22T21:14:52-04:00

template haskell: use a precise condition when implicitly lifting

Implicit lifting corrects a level error by replacing references to `x`
with `$(lift x)`, therefore you can use a level `n` binding at level `n
+ 1`, if it can be lifted.

Therefore, we now have a precise check that the use level is 1 more than
the bind level.

Before this bug was not observable as you only had 0 and 1 contexts but
it is easily evident when using explicit level imports.

Fixes #26088

5144b22f

by Andreas Klebinger at 2025-07-22T21:15:34-04:00

Add since tag and more docs for do-clever-arg-eta-expansion

Fixes #26113

c865623b

by Andreas Klebinger at 2025-07-22T21:15:34-04:00

Add since tag for -fexpose-overloaded-unfoldings

Fixes #26112

49a44ab7
by Simon Hengel at 2025-07-23T17:59:55+07:00
```
Refactor GHC.Driver.Errors.printMessages
```

84711c39

by Simon Hengel at 2025-07-23T18:27:34+07:00

Respect `-fdiagnostics-as-json` for error messages from pre-processors

(fixes #25480)

d046b5ab

by Simon Hengel at 2025-07-24T06:12:05-04:00

Include the rendered message in -fdiagnostics-as-json output

This implements #26173.

d2b89603

by Ben Gamari at 2025-07-24T06:12:47-04:00

rts/Interpreter: Factor out ctoi tuple info tables into data

Instead of a massive case let's put this into data which we can reuse
elsewhere.

4bc78496

by Sebastian Graf at 2025-07-24T16:19:34-04:00

CprAnal: Detect recursive newtypes (#25944)

While `cprTransformDataConWork` handles recursive data con workers, it
did not detect the case when a newtype is responsible for the recursion.
This is now detected in the `Cast` case of `cprAnal`.

The same reproducer made it clear that `isRecDataCon` lacked congruent
handling for `AppTy` and `CastTy`, now fixed.

Furthermore, the new repro case T25944 triggered this bug via an
infinite loop in `cprFix`, caused by the infelicity in `isRecDataCon`.
While it should be much less likely to trigger such an infinite loop now
that `isRecDataCon` has been fixed, I made sure to abort the loop after
10 iterations and emitting a warning instead.

Fixes #25944.

0a583689

by Sylvain Henry at 2025-07-24T16:20:26-04:00

STM: don't create a transaction in the rhs of catchRetry# (#26028)

We don't need to create a transaction for the rhs of (catchRetry#)
because contrary to the lhs we don't need to abort it on retry. Moreover
it is particularly harmful if we have code such as (#26028):

  let cN = readTVar vN >> retry
      tree = c1 `orElse` (c2 `orElse` (c3 `orElse` ...))
  atomically tree

Because it will stack transactions for the rhss and the read-sets of all
the transactions will be iteratively merged in O(n^2) after the
execution of the most nested retry.

a49eca26

by Simon Peyton Jones at 2025-07-25T09:49:58+01:00

Renaming around predicate types

.. we were (as it turned out) abstracting over
type-class selectors in SPECIALISATION rules!

Wibble isEqPred

f80375dd

by Simon Peyton Jones at 2025-07-25T09:49:58+01:00

Refactor of Specialise.hs

This patch just tidies up `specHeader` a bit, removing one
of its many results, and adding some comments.

No change in behaviour.

Also add a few more `HasDebugCallStack` contexts.

1bd12371

by Simon Peyton Jones at 2025-07-25T09:49:58+01:00

Improve treatment of SPECIALISE pragmas -- again!

This MR does another major refactor of the way that SPECIALISE
pragmas work, to fix #26115, #26116, #26117.

* We now /always/ solve forall-constraints in an all-or-nothing way.
  See Note [Solving a Wanted forall-constraint] in GHC.Tc.Solver.Solve

  This means we might have unsolved quantified constraints, which need
  to be reported.  See `inert_insts` in `getUnsolvedInerts`.

* I refactored the short-cut solver for type classes to work by
  recursively calling the solver rather than by having a little baby
  solver that kept being not clever enough.
  See Note [Shortcut solving] in GHC.Tc.Solver.Dict

* I totally rewrote the desugaring of SPECIALISE pragmas, again.
  The new story is in Note [Desugaring new-form SPECIALISE pragmas]
  in GHC.HsToCore.Binds

  Both old-form and new-form SPECIALISE pragmas now route through the same
  function `dsSpec_help`.   The tricky function `decomposeRuleLhs` is now used only
  for user-written RULES, not for SPECIALISE pragmas.

* I improved `solveOneFromTheOther` to account for rewriter sets. Previously
  it would solve a non-rewritten dict from a rewritten one.  For equalities
  we were already dealing with this, in

Some incidental refactoring

* A small refactor: `ebv_tcvs` in `EvBindsBar` now has a list of coercions, rather
  than a set of tyvars.  We just delay taking the free vars.

* GHC.Core.FVs.exprFVs now returns /all/ free vars.
  Use `exprLocalFVs` for Local vars.
  Reason: I wanted another variant for /evidence/ variables.

* Ues `EvId` in preference to `EvVar`.  (Evidence variables are always Ids.)
  Rename `isEvVar` to `isEvId`.

* I moved `inert_safehask` out of `InertCans` and into `InertSet` where it
  more properly belongs.

Compiler-perf changes:
  * There was a palpable bug (#26117) which this MR fixes in
    newWantedEvVar, which bypassed all the subtle overlapping-Given
    and shortcutting logic.  (See the new `newWantedEvVar`.)  Fixing this
    but leads to extra dictionary bindings; they are optimised away quickly
    but they made CoOpt_Read allocate 3.6% more.

  * Hpapily T15164 improves.

  * The net compiler-allocation change is 0.0%

Metric Decrease:
    T15164
Metric Increase:
    CoOpt_Read
    T12425

953fd8f1

by Simon Peyton Jones at 2025-07-25T09:49:58+01:00

Solve forall-constraints immediately, or not at all

This MR refactors the constraint solver to solve forall-constraints immediately,
rather than emitting an implication constraint to be solved later.

The most immediate motivation was that when solving quantified constraints
in SPECIALISE pragmas, we really really don't want to leave behind half-
solved implications.  Also it's in tune with the approach of the new
short-cut solver, which recursively invokes the solver.

It /also/ saves quite a bit of plumbing; e.g

  - The `wl_implics` field of `WorkList` is gone,

  - The types of `solveSimpleWanteds` and friends are simplified.

  - An EvFun contains binding, rather than an EvBindsVar ref-cell that
    will in the future contain bindings.  That makes `evVarsOfTerm`
    simpler.  Much nicer.

It also improves error messages a bit.

All described in Note [Solving a Wanted forall-constraint] in
GHC.Tc.Solver.Solve.

One tiresome point: in the tricky case of `inferConstraintsCoerceBased`
we make a forall-constraint.  This we /do/ want to partially solve, so
we can infer a suitable context. (I'd be quite happy to force the user to
write a context, bt I don't want to change behavior.)  So we want to generate
an /implication/ constraint in `emitPredSpecConstraints` rather than a
/forall-constraint/ as we were doing before.  Discussed in (WFA3) of
the above Note.

Incidental refactoring

* `GHC.Tc.Deriv.Infer.inferConstraints` was consulting the state monad for
  the DerivEnv that the caller had just consulted.  Nicer to pass it as an
  argument I think, so I have done that.  No change in behaviour.

6921ab42

by Simon Peyton Jones at 2025-07-25T09:49:58+01:00

Remove duplicated code in Ast.hs for evTermFreeVars

This is just a tidy up.

1165f587
by Simon Peyton Jones at 2025-07-25T09:49:58+01:00
```
Small tc-tracing changes only
```

0776ffe0

by Simon Hengel at 2025-07-26T04:54:20-04:00

Respect `-fdiagnostics-as-json` for core diagnostics (see #24113)

cc1116e0
by Andrew Lelechenko at 2025-07-26T04:55:01-04:00
```
docs: add since pragma to Data.List.NonEmpty.mapMaybe
```

ee2dc248

by Simon Hengel at 2025-07-31T06:25:35-04:00

Update comments on `OptKind` to reflect the code reality

b029633a

by Wen Kokke at 2025-07-31T06:26:21-04:00

rts: Disable --eventlog-flush-interval unless compiled with -threaded.

This commit fixes issue #26222:
Using --eventlog-flush-interval with the non-threaded RTS leads to eventlog corruption.
https://gitlab.haskell.org/ghc/ghc/-/issues/26222

This commit makes three changes when code is compiled against the non-threaded RTS:

1. It disables the --eventlog-flush-interval flag.
2. It disables the documentation for the --eventlog-flush-interval flag.
3. It disables the relevant state from RtsConfig and code from Timer.
4. It updates the entry for --eventlog-flush-interval in the users guide.

31159f1d

by Wen Kokke at 2025-07-31T06:26:21-04:00

rts: Split T20006 into tests with and without -threaded

618687ef

by Simon Hengel at 2025-07-31T06:27:03-04:00

docs/users_guide/win32-dlls.rst: Remove references to `readline`

083e40f1

by Rodrigo Mesquita at 2025-08-01T04:38:23-04:00

debugger: Uniquely identify breakpoints by internal id

Since b85b11994e0130ff2401dd4bbdf52330e0bcf776 (support inlining
breakpoints), a breakpoint has been identified at runtime by *two* pairs
of <module,index>.

- The first, aka a 'BreakpointId', uniquely identifies a breakpoint in
  the source of a module by using the Tick index. A Tick index can index
  into ModBreaks.modBreaks_xxx to fetch source-level information about
  where that tick originated.

    - When a user specifies e.g. a line breakpoint using :break, we'll reverse
      engineer what a Tick index for that line
    - We update the `BreakArray` of that module (got from the
      LoaderState) at that tick index to `breakOn`.
    - A BCO we can stop at is headed by a BRK_FUN instruction. This
      instruction stores in an operand the `tick index` it is associated
      to. We look it up in the associated `BreakArray` (also an operand)
      and check wheter it was set to `breakOn`.

- The second, aka the `ibi_info_mod` + `ibi_info_ix` of the
  `InternalBreakpointId`, uniquely index into the `imodBreaks_breakInfo`
  -- the information we gathered during code generation about the
  existing breakpoint *ocurrences*.

  - Note that with optimisation there may be many occurrences of the
    same source-tick-breakpoint across different modules. The
    `ibi_info_ix` is unique per occurrence, but the `bi_tick_ix` may be
    shared. See Note [Breakpoint identifiers] about this.

  - Note that besides the tick ids, info ids are also stored in
    `BRK_FUN` so the break handler can refer to the associated
    `CgBreakInfo`.

In light of that, the driving changes come from the desire to have the
info_id uniquely identify the breakpoint at runtime, and the source tick
id being derived from it:

- An InternalBreakpointId should uniquely identify a breakpoint just
  from the code-generation identifiers of `ibi_info_ix` and `ibi_info_mod`.
  So we drop `ibi_tick_mod` and `ibi_tick_ix`.
- A BRK_FUN instruction need only record the "internal breakpoint id",
  not the tick-level id.
  So we drop the tick mod and tick index operands.
- A BreakArray should be indexed by InternalBreakpointId rather than
  BreakpointId

That means we need to do some more work when setting a breakpoint.
Specifically, we need to figure out the internal ids (occurrences of a
breakpoint) from the source-level BreakpointId we want to set the
breakpoint at (recall :break refers to breaks at the source level).

Besides this change being an improvement to the handling of breakpoints
(it's clearer to have a single unique identifier than two competing
ones), it unlocks the possibility of generating "internal" breakpoints
during Cg (needed for #26042).
It should also be easier to introduce multi-threaded-aware `BreakArrays`
following this change (needed for #26064).

Se also the new Note [ModBreaks vs InternalModBreaks]

On i386-linux:

-------------------------
Metric Decrease:
    interpreter_steplocal
-------------------------

bf03bbaa

by Simon Hengel at 2025-08-01T04:39:05-04:00

Don't use MCDiagnostic for `ghcExit`

This changes the error message of `ghcExit` from

```
<no location info>: error:
Compilation had errors

```
to
```

Compilation had errors

```

a889ec75

by Simon Hengel at 2025-08-01T04:39:05-04:00

Respect `-fdiagnostics-as-json` for driver diagnostics (see #24113)

81577fe7

by Ben Gamari at 2025-08-02T04:29:39-04:00

configure: Allow override of CrossCompiling

As noted in #26236, the current inference logic is a bit simplistic. In
particular, there are many cases (e.g. building for a new libc) where
the target and host triples may differ yet we are still able to run the
produced artifacts as native code.

Closes #26236.

01136779
by Andreas Klebinger at 2025-08-02T04:30:20-04:00
```
rts: Support COFF BigObj files in archives.
```

0813650d