GitLab

Simon Peyton Jones pushed to branch wip/T20264 at Glasgow Haskell Compiler / GHC

Commits:

0e0231e7

by Matthew Pickering at 2025-03-28T18:36:33-04:00

hadrian: Make hash_unit_ids into a flavour transformer (and enable for release flavour)

The primary reason for this change is to make the `release` flavour
enable `--hash-unit-ids` by default without any further user intervention.

* Packagers don't have to be aware of this special flag they should be
  using.
* release builds on CI are uniformly testing with hashes (see !13418)

Fixes #25379

9fc54c12

by Rodrigo Mesquita at 2025-03-28T18:37:10-04:00

driver: Move DynFlags consistency fixes off Main

These consistency fixes found in Main.hs are required for the proper
functioning of the compiler and should live together with all remaining
fixes in `makeDynFlagsConsistent`.

This is especially relevant to GHC applications that shouldn't have to
copy/fix themselves possibly inconsistent DynFlags.

Additionally, outputs information when verbosity is high about these
consistency fixes that were previously quiet, adds information to the
Note on consistency of DynFlags, and improves one of the fixes that
incorrectly used `dynNow`.

2fdd0be9

by sheaf at 2025-03-28T18:37:53-04:00

Remove GhcHint from TcRnNotInScope constructor

This is a tiny refactoring which:

  - removes GhcHint/ImportError fields from some constructors of
    TcRnMessage, using the TcRnMessageDetailed mechanism instead to
    report this informaiton:
      - removes the GhcHint and ImportErrors fields from TcRnNotInScope
      - removes the GhcHint field from TcRnTermNameInType
  - ensures that we only include these hints and import errors when the
    -fhelpful-errors flag is turned on

Fixes #25874

9e5cd064

by ARATA Mizuki at 2025-03-31T14:53:34-04:00

Better support for SSE3 and SSE4.1

In particular:

* Pass appropriate attributes to LLVM
* Define preprocessor macros for them

c2c7dd51

by ARATA Mizuki at 2025-03-31T14:53:34-04:00

x86: Add support for SSSE3

This commit adds the `-mssse3` flag, which controls usage of SSSE3 instructions in x86 code generation.

d7c62580

by ARATA Mizuki at 2025-03-31T14:53:34-04:00

x86 NCG SIMD: Implement 128-bit integer vector arithmetics

This commit implements the following operations on integer vectors:

* negateIntNXM#
* plus{Int,Word}NXM#
* minus{Int,Word}NXM#
* times{Int,Word}NXM#
* quot{Int,Word}NXM#
* rem{Int,Word}NXM#
* min{Int,Word}NXM#
* max{Int,Word}NXM#

where (N,M) is one of (8,16), (16,8), (32,4), or (64,2).

Closes #25643

f5ea4e7e

by ARATA Mizuki at 2025-03-31T14:53:34-04:00

x86 NCG SIMD: Implement 128-bit integer vector shuffle

This commit implements the following operations:

* shuffle{Int,Word}8X16#
* shuffle{Int,Word}16X8#
* shuffle{Int,Word}32X4#
* shuffle{Int,Word}64X2#

See #25643

5eeb6645

by Simon Peyton Jones at 2025-03-31T14:54:16-04:00

Re-jig the way that the Simplifier tries RULES

As #25170 showed, if a new RULE appears, it could change the simplifier's
behaviour a bit, even if it never fires; and that messes up deterministic
compilation.  (This was particularly nasty if the rule wasn't even transitively
below the module being compiled.)

This MR rejigs the use of `tryRules` so that behaviour does not change
when a new, unrelated RULE is added.  It's described in

* Note [When to apply rewrite rules]
* Note [tryRules: plan (BEFORE)]
* Note [tryRules: plan (AFTER)]

The main change is in the refactored version of
  * simplOutId
  * rebuildCall
The little state machine that was embedded in ArgInfo is gone.

As I wandered around the Simplifier I also found opportunities for
some loosely-related refactoring:

* In several places, the /substitution/ in the SimpleEnv is empty;
  all we care about is the in-scope set and the flags.  So
  - I made a synonym `SimplEnvIS` that embodies that invariant,
  - used it in a number of type signatures (notably `rebuild`)
  - added some assertion checks (via `checkSimlEnvIS`)

* I moved the hanlding of `runRW` out of `rebuildCall` (where we
  would have to test repeatedly) and into the new `simplOutId`, which
  fires up `rebuildCall`. Now it is only tested once.

-------------------------
Metric Decrease:
    T9020
    T9961
-------------------------

f534474a

by sheaf at 2025-03-31T14:54:59-04:00

Add comment: no qualified Names in the LocalRdrEnv

This commit adds a reference to section 5.5.1 of the Haskell 2010 report,
to explain that qualified names can't occur in the LocalRdrEnv.

Fixes #25875

d5ea80c6

by Patrick at 2025-03-31T14:55:42-04:00

Fix deadlock/loop in interface rehydration (#25858)

In #25858, GHC hangs when processing modules with class defaults due to a
circular dependency in the interface rehydration process. The deadlock/loop
occurred when eager class defaults rehydration accessed not-yet-complete module details.

To fix the immediate deadlock/loop.
`tcIfaceDefaults` is refactored, we use the class name directly from the iface
and use `forM` for lazy loading the class, which algins with the handling of other fields
of ModDetails. This laziness ensure rehydration waits for HomePackageTable (HPT) to
be updated and prevent premature evaluation of ModDetails inside `fixIO``.

As suggested by Matthew, class defaults importing is also refactored
to align with the compiler's established interface loading conventions.
- add class defaults field to ExternalPackageState (EPS).
- rehydrate and store class defaults in EPS at `loadInterface`.
- Instead of using `tcIfaceDefaults` in `tcRnImports`, we add and use
  `tcGetClsDefaults` to read defaults directly from HPT or EPS
  when importing modules.

Tests:
- T25858, T25858v1-2: Test class hydration in defaults
- T25858v3-4: Test type list hydration in defaults

New Note [Tricky rehydrating IfaceDefaults loop] is added.

Thanks to @sheaf (Sam), @mpickering (Matthew), and @simonpj (Simon) for their
valuable input and analysis.

Fixes #25858.

2d419d8d

by Matthew Pickering at 2025-04-02T16:12:36-04:00

Use unsafePerformIO in definition of computeFingerprint

computeFingerprint is morally a pure function, which is implemented by
mutating a buffer. Using unsafePerformIO inside the definition allows it
to be used in pure contexts, fixing one place where an ad-hoc call to
unsafePerformIO is already needed.

ccdf979b

by Matthew Pickering at 2025-04-02T16:12:37-04:00

driver: Fix recompilation checking for exported defaults

Since the exported defaults are not associated with any identifier from
the module, they are just added to the export hash rather than
the fine-grained recompilation logic.

Fixes #25855

c5bf9892

by Matthew Pickering at 2025-04-02T16:12:37-04:00

driver: Fix recompilation checking for COMPLETE pragmas

A {-# COMPLETE P, Q #-} pragma is associated with the pattern synonyms P
and Q during recompilation checking. Therefore, the existence of a
pattern synonym becomes part of the ABI hash for P and Q.

Then if a module uses these pattern synonyms and a complete pragma
changes, it will trigger recompilation in that module.

Fixes #25854

d0fd9370

by sheaf at 2025-04-02T16:14:05-04:00

Handle named default exports separately

This commit changes the way we check for duplicate exports of named
default declarations. They are now treated entirely separately from
other exports, because in an export list of the form

  module M ( default Cls, Cls )

the default declaration does not export the class 'Cls', but only its
default declarations.

Also fixes a bug in Backpack where named default exports were getting
dropped entirely. No test for that.

Fixes #25857

62d04494

by Cheng Shao at 2025-04-03T05:56:17-04:00

ci: add x86_64-linux-ubuntu24_04 nightly/release jobs

327952e4

by Cheng Shao at 2025-04-03T05:56:17-04:00

rel-eng: add ubuntu24_04 bindists to ghcup metadata and fetch gitlab scripts

aa1e3b8b

by sheaf at 2025-04-03T05:57:24-04:00

GHC settings: always unescape escaped spaces

In #25204, it was noted that GHC didn't properly deal with having
spaces in its executable path, as it would compute an invalid path
for the C compiler.

The original fix in 31bf85ee49fe2ca0b17eaee0774e395f017a9373 used a
trick: escape spaces before splitting up flags into a list. This fixed
the behaviour with extra flags (e.g. -I), but forgot to also unescape
for non-flags, e.g. for an executable path (such as the C compiler).

This commit rectifies this oversight by consistently unescaping the
spaces that were introduced in order to split up argument lists.

Fixes #25204

34a9b55d

by lazyLambda at 2025-04-04T06:22:26-04:00

Driver: make MonadComprehensions imply ParallelListComp

This commit changes GHC.Driver.Flags.impliedXFlags to make the
MonadComprehensions extension enable the ParallelListComp extension.

Fixes #25645

d99eb7cd

by sheaf at 2025-04-04T06:23:28-04:00

NamedDefaults: handle poly-kinded unary classes

With this commit, we accept named default declarations for poly-kinded
classes such as Typeable, e.g.

  default Typeable (Char)

This used to fail because we assumed the kind of the class was monomorphic,
e.g.

  Type -> Constraint
  (Type -> Type) -> Constraint
  Nat -> Constraint

Now, we can handle a simple polymorphic class such as

  Typeable :: forall k. k -> Constraint

Note that we keep the restriction that the class must only have
one visible argument.

This is all explained in the new Note [Instance check for default declarations]
in GHC.Tc.Gen.Default.

Fixes #25882

4cbc90de

by sheaf at 2025-04-04T11:39:05-04:00

LLVM: add type annotations to AtomicFetch_cmm.cmm

e2237305

by sheaf at 2025-04-04T11:39:05-04:00

Cmm lint: lint argument types of CallishMachOps

This commit adds a new check to Cmm lint to ensure that the argument
types to a CallishMachOp are correct. The lack of this check was
detected in the AtomicFetch test: the literals being passed as the
second arguments to operations such as 'fetch_add', 'fetch_and'... were
of the wrong width, which tripped up the LLVM backend.

9363e547

by Cheng Shao at 2025-04-04T11:39:50-04:00

ci: add ghc-wasm-meta integration testing jobs

This patch adds ghc-wasm-meta integration testing jobs to the CI
pipeline, which are only triggered via the `test-wasm` MR label or
manually when the `wasm` label is set.

These jobs will fetch the wasm bindists and test them against a
variety of downstream projects, similarly to head.hackage jobs for
native bindists, offering a convenient way to catch potential
downstream breakage while refactoring the wasm backend.

27029e60

by Adam Gundry at 2025-04-04T11:40:36-04:00

base: Minor fixes to GHC.Records haddocks

This corrects a stale reference to OverloadedRecordFields (which should
be OverloadedRecordDot), fixes the haddock link syntax and adds an
@since pragma.

f827c4c6

by Rodrigo Mesquita at 2025-04-07T11:22:10-04:00

Parametrize default logger action with Handles

Introduce `defaultLogActionWithHandles` to allow GHC applications to use
GHC's formatting but using custom handles.

`defaultLogAction` is then trivially reimplemented as
```
defaultLogActionWithHandles stdout stderr
```

5dade5fd

by sheaf at 2025-04-07T11:23:02-04:00

Finer-grained recompilation checking for exports

This commit refines the recompilation checking logic, to avoid
recompiling modules with an explicit import list when the modules they
import start exporting new items.

More specifically, when:

  1. module N imports module M,
  2. M is changed, but in a way that:
      a. preserves the exports that N imports
      b. does not introduce anything that forces recompilation downstream,
         such as orphan instances

then we no longer require recompilation of N.

Note that there is more to (2a) as initially meets the eye:

  - if N includes a whole module or "import hiding" import of M,
    then we require that the export list of M does not change,
  - if N only includes explicit imports, we check that the imported
    items don't change, e.g.

      - if we have @import M(T(K, f), g)@, we must check that N
        continues to export all these identifiers, with the same Avail
        structure (i.e. we should error if N stops bundling K or f with
        T)
      - if we have @import M(T(..))@, we must check that the children
        of T have not changed

See Note [When to recompile when export lists change?] in GHC.Iface.Recomp.

This is all tested in the new tests RecompExports{1,2,3,4,5}

Fixes #25881

f32d6c2b

by Andreas Klebinger at 2025-04-07T22:01:25-04:00

NCG: AArch64 - Add -finter-module-far-jumps.

When enabled the arm backend will assume jumps to targets outside of the
current module are further than 128MB away.

This will allow for code to work if:
* The current module results in less than 128MB of code.
* The whole program is loaded within a 4GB memory region.

We have seen a few reports of broken linkers (#24648) where this flag might allow
a program to compile/run successfully at a very small performance cost.

-------------------------
Metric Increase:
    T783
-------------------------

553c280b

by Andreas Klebinger at 2025-04-07T22:02:11-04:00

Revert "rts: fix small argument passing on big-endian arch (fix #23387)"

Based on analysis documented in #25791 this doesn't fully fix the big
while introducing new bugs on little endian architectures.

A more complete fix will have to be implemented to fix #23387

This reverts commit 4f02d3c1a7b707e609bb3aea1dc6324fa19a5c39.

b0dc6599

by Andreas Klebinger at 2025-04-07T22:02:11-04:00

Interpreter: Fixes to handling of subword value reads/writes.

Load subword values as full words from the stack truncating/expanding as
neccesary when dealing with subwords. This way byte order is implicitly
correct.

This commit also fixes the order in which we are pushing literals onto
the stack on big endian archs.

Last but not least we enable a test for ghci which actually tests these
subword operations.

ed38c09b

by Cheng Shao at 2025-04-07T22:02:53-04:00

testsuite: don't test WasmControlFlow stdout

This patch solves a potential test flakiness in `WasmControlFlow` by
removing `WasmControlFlow.stdout` which is not so portable/stable as
it seems. See added `Note [WasmControlFlow]` for more detailed
explanation.

f807c590
by Rodrigo Mesquita at 2025-04-08T17:41:51-04:00
```
debugger: Add docs to obtainTermFromId
```

5dba052d

by Rodrigo Mesquita at 2025-04-08T17:41:51-04:00

Move logic to find and set Breakpoint to GHC

Breakpoints are uniquely identified by a module and an index unique
within that module. `ModBreaks` of a Module contains arrays mapping from
this unique breakpoint index to information about each breakpoint. For
instance, `modBreaks_locs` stores the `SrcSpan` for each breakpoint.

To find a breakpoint using the line number you need to go through all
breakpoints in the array for a given module and look at the line and
column stored in the `SrcSpan`s. Similarly for columns and finding
breakpoints by name.

This logic previously lived within the `GHCi` application sources,
however, it is common to any GHC applications wanting to set
breakpoints, like the upcoming `ghc-debugger`.

This commit moves this logic for finding and setting breakpoints to the
GHC library so it can be used by both `ghci` and `ghc-debugger`.

bc0b9f73

by Rodrigo Mesquita at 2025-04-08T17:41:51-04:00

Refactor and move logic for identifier breakpoints

Breakpoints can be set on functions using syntax of the form
`[Module.]function`. The parsing, resolution (e.g. inferring implicit
module), and validation of this syntax for referring to functions was
tightly coupled with its GHCi use.

This commit extracts the general purpose bits of resolving this syntax
into `GHC.Runtime.Debugger.Breakpoints` so it can be further used by
other GHC applications and to improve the code structure of GHCi.

Moreover, a few utilities that do splitting and joining of identifiers
as strings were moved to `GHC.Runtime.Eval.Utils`, which also can be
used in the future to clean up `GHC.Runtime.Eval` a bit.

4f728d21
by Rodrigo Mesquita at 2025-04-08T17:41:51-04:00
```
debugger: derive Ord for BreakpointIds
```

5528771c

by Rodrigo Mesquita at 2025-04-08T17:41:51-04:00

debugger: Move context utils from GHCi to GHC

Moves `enclosingTickSpan`, `getCurrentBreakSpan`, and
`getCurrentBreakModule`, general utilities on the internal debugger
state, into the GHC library.

4871f543

by sheaf at 2025-04-08T17:42:43-04:00

Implicit quantification in type synonyms: add test

This adds a test for ticket #24090, which involves implicit
quantification in type synonyms.
The underlying issue was fixed in 0d4ee209dfe53e5074d786487f531dabc36d561c.

48917d3c

by sheaf at 2025-04-08T17:42:44-04:00

Turn on implicit-rhs-quantification by default

This flag was added to GHC 9.8, and will be removed in a future GHC
release. In preparation, this commit adds it to the default warning
flags.

629be068

by Rodrigo Mesquita at 2025-04-08T17:43:26-04:00

debugger: Add breakpoints to every Stmt

While single-stepping through a Haskell program we stop at every
breakpoint. However, we don't introduce breakpoints at every single
expression (e.g. single variables) because they would be too many and
uninteresting.

That said, in a do-block, it is expected that stepping over would break
at every line, even if it isn't particularly interesting (e.g. a single
arg like getArgs). Moreover, let-statements in do-blocks, despite only
being evaluated once needed, lead to surprising jumps while stepping
through because some have outermost (outside the let) breakpoints
while others don't.

This commit makes every statement in a do-block have a breakpoint.
This leads to predictable stepping through in a do-block.
Duplicate breakpoints in the same location are avoided using the
existing blacklist mechanism, which was missing a check in one relevant place.

Fixes #25932

99a3affd

by Matthew Pickering at 2025-04-08T17:44:08-04:00

driver: refactor: Split downsweep and MakeAction into separate modules.

This will facilitate using the downsweep functions in other parts of
the compiler than just --make mode.

Also, the GHC.Driver.Make module was huge. Now it's still huge but
slightly smaller!

ecfec4df

by sheaf at 2025-04-09T14:13:12-04:00

Store user-written qualification in the GhcRn AST

This commit ensures we store the original user-written module
qualification in the renamed AST. This allows us to take into account
the user-written qualification in error messages.

Fixes #25877

97c884e2

by sheaf at 2025-04-09T14:13:12-04:00

TcRnIllegalTermLevelUse: simpler error when possible

This commit makes GHC emit a simple error message in the case of an
illegal term-level use of a data constructor: we will try to report an
out-of-scope error instead of a "Illegal term level use" error, as the
latter might be a bit overwhelming for newcomers.

We do this when we have a data constructor import suggestion to provide
to the user. For example:

  module M where { data A = A }

  module N where
    import M(A)

    x = Bool
    -- Illegal term-level use of Bool

    y = A
    -- Data constructor not in scope: A.
    -- Perhaps add 'A' to the import list of 'M'.

This commit also revamps the "similar names" suggestion mechanism,
and in particular its treatment of name spaces. Now, which name spaces
we suggest is based solely on what we are looking for, and no longer on
the NameSpace of the Name we have. This is because, for illegal term-level
use errors, it doesn't make much sense to change the suggestions based
on the fact that we resolved to e.g. a type constructor/class; what
matters is what we were expecting to see in this position.
See GHC.Rename.Unbound.{suggestionIsRelevant,relevantNameSpace} as well
as the new constructors to GHC.Tc.Errors.Types.WhatLooking.

Fixes #23982

bff645ab

by Rodrigo Mesquita at 2025-04-09T14:13:57-04:00

driver: Split Session functions out of Main

This commit moves out functions that help in creating and validating a
GHC multi session from Main into the ghc library where they can be used by
other GHC applications.

Moreover, `Mode` processing and `checkOptions` linting were moved to
separate modules within the ghc-bin executable package.

In particular:

- Move `Mode` types and functions (referring to the mode GHC is running
  on) to `ghc-bin:GHC.Driver.Session.Mode`

- Move `checkOptions` and aux functions, which validates GHC DynFlags
  based on the mode, to `ghc-bin:GHC.Driver.Session.Lint`

- Moves `initMulti`, `initMake`, and aux functions, which initializes a make/multi-unit
  session, into `ghc:GHC.Driver.Session.Units`.

501b015e
by Rodrigo Mesquita at 2025-04-09T14:13:57-04:00
```
docs: Improve haddock of ExecComplete
```

dea98988

by Andreas Klebinger at 2025-04-09T19:23:57-04:00

Avoid oversaturing constructor workers.

Constructor applications always need to take the exact number of
arguments. If we can't ensure that instead apply the constructor worker
like a regular function.

Fixes #23865

f1acdd2c

by sheaf at 2025-04-09T19:25:41-04:00

NamedDefaults: require the class to be standard

We now only default type variables if they only appear in constraints
of the form `C v`, where `C` is either a standard class or a class with
an in-scope default declaration.

This rectifies an oversight in the original implementation of the
NamedDefault extensions that was remarked in #25775; that implementation
allowed type variables to appear in unary constraints which had arbitrary
classes at the head.

See the rewritten Note [How type-class constraints are defaulted] for
details of the implementation.

Fixes #25775
Fixes #25778

5712e0d6

by Vladislav Zavialov at 2025-04-10T05:17:38+00:00

Retry type/class declarations and instances (#12088)

Retry type/class declarations and instances to account for non-lexical
dependencies arising from type/data family instances.

This patch improves the kind checker's ability to use type instances in kind
checking of other declarations in the same module.

* Key change: tcTyAndClassDecls now does multiple passes over the TyClGroups,
  as long as it is able to make progress.
  See the new Note [Retrying TyClGroups] in GHC.Tc.TyCl

* Supporting change: FVs of a TyClGroup are now recorded in its extension
  field, namely XCTyClGroup.
  See the new Note [Prepare TyClGroup FVs] in GHC.Rename.Module

* Instances are no longer inserted at the earliest positions where their FVs
  are bound. This is a simplification.
  See the new Note [Put instances at the end] in GHC.Rename.Module

* Automatic unpacking is now more predictable, but fewer fields get unpacked
  by default. Use explicit {-# UNPACK #-} pragmas instead.
  See the new Note [Flaky -funbox-strict-fields with type/data families]

For the wide range of newly accepted programs, consult the added test cases.

Fixed tickets:
    #12088, #12239, #14668, #15561, #16410, #16448, #16693,
    #19611, #20875, #21172, #22257, #25238, #25834

Metric Decrease:
    T8095

bc73a78d

by sheaf at 2025-04-10T15:07:24-04:00

checkFamApp: don't be so eager to cycle break

As remarked in #25933, a pure refactoring of checkTyEqRhs in
ab77fc8c7adebd610aa0bd99d653f9a6cc78a374 inadvertently changed behaviour,
as it caused GHC to introduce cycle-breaker variables in some
unnecessary circumstances.

This commit refactors 'GHC.Tc.Utils.Unify.checkFamApp' in a way that
should restore the old behaviour, so that, when possible, we first
recur into the arguments and only introduce a cycle breaker if this
recursion fails (e.g. due to an occurs check failure).

Fixes #25933

3acd8182

by Andreas Klebinger at 2025-04-10T22:32:12-04:00

Expand docs for RTS flag `-M`.

The behaviour of how/when exceptions are raised was not really covered
in the docs.

026c1a39

by Adam Sandberg Ericsson at 2025-04-10T22:32:56-04:00

add cases for more SchedulerStatus codes in rts_checkSchedStatus

5977c6a1

by sheaf at 2025-04-10T22:33:46-04:00

Squash warnings in GHC.Runtime.Heap.Inspect

There were incomplete record selector warnings in GHC.Runtime.Heap.Inspect
due to the use of the partial 'dataArgs' record selector. This is fixed
by passing the fields to the 'extractSubTerms' function directly,
rather than passing a value of the parent data type.

6a3e38f5

by Andreas Klebinger at 2025-04-11T15:13:53-04:00

hadrian: Make ghcWithInterpreter the universal source of truth about availability of the interpreter

We were doing some ad-hoc checks in different places in hadrian to
determine whether we supported the interprter or not. Now this check if
confined to one function, `ghcWithInterpreter`, and all the places which
use this information consult `ghcWithInterpreter` to determine what to
do.

Fixes #25533.

207de6f1

by Matthew Pickering at 2025-04-11T15:14:37-04:00

testsuite: Fix running TH tests with profiled dynamic compiler

Previously, I had failed to update the ghc_th_way_flags logic for the
profiled dynamic compiler.

In addition to this `ghc_dynamic` was incorrectly set for profiled
dynamic compiler.

I also updated MultiLayerModulesTH_OneShot test to work for any compiler
linkage rather than just dynamic.

Fixes #25947

-------------------------
Metric Decrease:
    MultiLayerModulesTH_Make
-------------------------

5455f2b9

by Matthew Pickering at 2025-04-12T08:31:36-04:00

driver: Add support for "Fixed" nodes in the ModuleGraph

A fixed node in the module graph is one which we presume is already
built. It's therefore up to the user to make sure that the interface
file and any relevant artifacts are available for a fixed node.

Fixed/Compile nodes are represented by the ModuleNodeInfo type, which
abstracts the common parts of Fixed/Compile nodes with accessor
functions of type `ModuleNodeInfo -> ...`.

Fixed nodes can only depend on other fixed nodes. This invariant can be
checked by the function `checkModuleGraph` or `mkModuleGraphChecked`.

--make mode is modified to work with fixed mode. In order to "compile" a
fixed node, the artifacts are just loaded into the HomePackageTable.
Currently nothing in the compiler will produce Fixed nodes but this is
tested with the FixedNodes GHC API test.

In subsequent patches we are going to remove the ExternalModuleGraph and
use Fixed nodes for modules in the module graph in oneshot mode.

Fixes #25920

ad64d5c2

by Cheng Shao at 2025-04-12T08:32:19-04:00

ci: remove manual case of ghc-wasm-meta downstream testing jobs

This patch removes the manual case of ghc-wasm-meta downstream testing
jobs; now the only way of including them in the pipeline and running
them is via the test-wasm label.

The reason of the removal is it proves to be problematic for MRs with
only the wasm label; the wasm job would succeed, then the pipeline
status would be waiting for manual action instead of succeeding. There
needs to be separate jobs for the label-triggered and manual-triggered
cases, but I don't think it's worth that extra complexity, the
label-triggered case is already sufficient.

b34890c7

by Vladislav Zavialov at 2025-04-13T01:08:21+03:00

Fix EmptyCase panic in tcMatches (#25960)

Due to faulty reasoning in Note [Pattern types for EmptyCase],
tcMatches was too keen to panic.

* Old (incorrect) assumption: pat_tys is a singleton list.
  This does not hold when \case{} is checked against a function type
  preceded by invisible forall. See the new T25960 test case.

* New (hopefully correct) assumption: vis_pat_tys is a singleton list.
  This should follow from:

    checkArgCounts :: MatchGroup GhcRn ... -> TcM VisArity
    checkArgCounts (MG { mg_alts = L _ [] })
      = return 1
    ...

84806ebc
by Vladislav Zavialov at 2025-04-13T11:40:08-04:00
```
Remove unused type: TokenLocation
```

05eb50df

by Vladislav Zavialov at 2025-04-13T19:16:38-04:00

Register EpToken in Parser.PostProcess.Haddock (#22558)

This change allows us to reject more badly placed Haddock comments.
Examples:

  module
    -- | Bad comment for the module
    T17544_kw where

  data Foo -- | Bad comment for MkFoo
    where MkFoo :: Foo

  newtype Bar -- | Bad comment for MkBar
    where MkBar :: () -> Bar

  class Cls a
      -- | Bad comment for clsmethod
    where
      clsmethod :: a

01944e5e

by Vladislav Zavialov at 2025-04-13T19:17:21-04:00

Reject puns in T2T (#24153)

This patch implements pun detection in T2T. Consider:

  x = 42
  f, g :: forall a -> ...
  f (type x) = g x

In accordance with the specification, the `g x` function call is renamed
as a term, so `x` refers to the top-level binding `x = 42`, not to the
type variable binding `type x` as one might expect.

This is somewhat counterintuitive because `g` expects a type argument.
Forbidding puns in T2T allows us to produce a helpful error message:

  Test.hs:5:16: error: [GHC-09591]
    Illegal punned variable occurrence in a required type argument.
    The name ‘x’ could refer to:
      ‘x’ defined at Test.hs:3:1
      ‘x’ bound at Test.hs:5:9

This commit is a follow up to 0dfb1fa799af254c8a1e1045fc3996af2d57a613
where checking for puns was left as future work.

cc580552

by Vladislav Zavialov at 2025-04-13T19:18:02-04:00

Additional test cases for #12088, #13790

Extract more test cases from ticket discussions, including multi-module
examples. Follow up to 5712e0d646f611dfbfedfd7ef6dff3a18c016edb

d47bf776

by Matthew Pickering at 2025-04-14T16:44:41+01:00

driver: Use ModuleGraph for oneshot and --make mode

This patch uses the `hsc_mod_graph` field for both oneshot and --make
mode. Therefore, if part of the compiler requires usage of the module
graph, you do so in a uniform way for the two different modes.

The `ModuleGraph` describes the relationship between the modules in the
home package and units in external packages. The `ModuleGraph` can be
queried when information about the transitive closure of a package is
needed. For example, the primary use of the ModuleGraph from within the
compiler is in the loader, which needs to know the transitive closure of
a module so it can load all the relevant objects for evaluation.

In --make mode, downsweep computes the ModuleGraph before any
compilation starts.

In oneshot mode, a thunk is created at the start of compilation, which
when forced will compute the module graph beneath the current module.
The thunk is only forced at the moment when the user uses Template
Haskell.

Finally, there are some situations where we need to discover what
dependencies to load but haven't loaded a module graph at all. In this
case, there is a fallback which computes the transitive closure on the
fly and doesn't cache the result. Presumably if you are going to call
getLinkDeps a lot, you would compute the right ModuleGraph before you
started.

Importantly, this removes the ExternalModuleGraph abstraction. This was quite
awkward to work with since it stored information about the home package
inside the EPS.

This patch will also be very useful when implementing explicit level
imports, which requires more significant use of the module graph in
order to determine which level instances are available at.

Towards #25795

-------------------------
Metric Decrease:
    MultiLayerModulesTH_Make
    MultiLayerModulesTH_OneShot
-------------------------

395e0ad1

by sheaf at 2025-04-16T12:33:26-04:00

base: remove .Internal modules (e.g. GHC.TypeLits)

This commit removes the following internal modules from base,
as per CLC proposal 217:

  - GHC.TypeNats.Internal
  - GHC.TypeLits.Internal
  - GHC.ExecutionStack.Internal

Fixes #25007

e0f3ff11

by Patrick at 2025-04-17T04:31:12-04:00

Refactor Handling of Multiple Default Declarations

Fixes: #25912, #25914, #25934

Previously, GHC discarded all loaded defaults (tcg_default) when local
defaults were encountered during typechecking. According to the
exportable-named-default proposal (sections 2.4.2 and 2.4.3), local
defaults should be merged into tcg_default, retaining any defaults
already present while overriding where necessary.

Key Changes:

* Introduce DefaultProvenance to track the origin of default declarations
  (local, imported, or built-in), replacing the original cd_module
  in ClassDefaults with cd_provenance :: DefaultProvenance.
* Rename tcDefaults to tcDefaultDecls, limiting its responsibility to only
  converting renamed class defaults into ClassDefaults.
* Add extendDefaultEnvWithLocalDefaults to merge local defaults into the
  environment, with proper duplication checks:
  - Duplicate local defaults for a class trigger an error.
  - Local defaults override imported or built-in defaults.
* Update and add related notes: Note [Builtin class defaults],
  Note [DefaultProvenance].
* Add regression tests: T25912, T25914, T25934.

Thanks sam and simon for the help on this patch.
Co-authored-by: sheaf <sam.derbyshire@gmail.com>

386f1854

by Teo Camarasu at 2025-04-17T04:31:55-04:00

template-haskell: Remove `addrToByteArrayName` and `addrToByteArray`

These were part of the implementation of the `Lift ByteArray` instance and were errornously exported because this module lacked an explicit export list. They have no usages on Hackage.

Resolves #24782

b96e2f77

by Sylvain Henry at 2025-04-18T20:46:33-04:00

RTS: remove target info and fix host info (#24058)

The RTS isn't a compiler, hence it doesn't have a target and we remove
the reported target info displayed by "+RTS --info". We also fix the
host info displayed by "+RTS --info": the host of the RTS is the
RTS-building compiler's target, not the compiler's host (wrong when
doing cross-compilation).

6d9965f4

by Sylvain Henry at 2025-04-18T20:46:33-04:00

RTS: remove build info

As per the discussion in !13967, there is no reason to tag the RTS with
information about the build platform.

d52e9b3f

by Vladislav Zavialov at 2025-04-18T20:47:15-04:00

Diagnostics: remove the KindMismatch constructor (#25957)

The KindMismatch constructor was only used as an intermediate
representation in pretty-printing.

Its removal addresses a problem detected by the "codes" test case:

  [GHC-89223] is untested (constructor = KindMismatch)

In a concious deviation from the usual procedure, the error code
GHC-89223 is removed entirely rather than marked as Outdated.
The reason is that it never was user-facing in the first place.

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.

0c34a817

by Joseph Fourment at 2025-04-22T17:44:10+01:00

compiler: introduce type variable unfoldings

The plan for #20264 is to introduce let-bound types to have observable sharing in types.
To avoid the need to carry an environment when dealing with occurrences of these type variables,
we embed the types they're bound to (if any) in a `tv_unfolding :: Maybe Type` attribute.
This way, one can look through let-bound type variables using `coreView` and friends.
In particular, definitional equality looks through unfoldings.

08b9fdfc
by Joseph Fourment at 2025-04-22T17:44:10+01:00
```
simple-opt: don't inline type-lets
```

a6b89e66

by Joseph Fourment at 2025-04-22T17:44:10+01:00

specialise: fix type-lets in DFun unfoldings

During specialisation, a dictionary being specialised gets a new unfolding by turning
`DFun \ bndrs      -> MkD @<T1> ... @<Tm> <op1> ... <opn>` into
`DFun \ spec_bndrs -> MkD @((\ bndrs -> TYPE: <T1>) spec_args) ... ((\ bndrs -> <opn>) spec_args)`
which in turns gets beta-reduced into
`DFun \ spec_bndrs -> MkD (let { bndrs = spec_args } in TYPE: <T1>) ... (let { bndrs = spec_args } in <opn>)`.
Previously, such let binders would immediately be substituted into the type so it didn't cause any issue,
but now we want to avoid inlining.
Arguments of the form `let { bndrs = spec_args } in TYPE: <T1>` are not considered as type arguments since they're
not of the canonical form `TYPE: something`.
This commit restores the previous behavior of substituting the specialised type arguments.
Alternatively, we could attach some floated type bindings to `DFun`s.

3885423d

by Joseph Fourment at 2025-04-22T17:44:10+01:00

occur-anal: implement occurence analysis for type variables

In order to find out let-bound type variables that are used only once, in the hope of inlining them,
we need to track type variables as well in the occurrence analiser. Just like Id's, we attach an
`OccInfo` to each (immutable) type variable, and we walk into types and coercions to accurately gather
occurrences.

9c6ca7a2

by Joseph Fourment at 2025-04-22T17:44:10+01:00

simplifier: don't inline type-lets

Keep propagating type-lets further down the pipeline, in the simplifier.
We also update CallArity, CprAnal, DmdAnal, WorkWrap, and Specialise to ignore type-lets.

96c73f5e