GitLab

Zubin pushed to branch wip/9.12.3-backports at Glasgow Haskell Compiler / GHC

Commits:

05640047

by Simon Peyton Jones at 2025-09-12T17:02:17+05:30

Take more care in zonkEqTypes on AppTy/AppTy

This patch fixes #26256.

See Note [zonkEqTypes and the PKTI] in GHC.Tc.Solver.Equality

(cherry picked from commit 18036d5205ac648bb245217519fed2fd931a9982)

42de45fa

by Andreas Klebinger at 2025-09-12T17:02:17+05:30

Make unexpected LLVM versions a warning rather than an error.

Typically a newer LLVM version *will* work so erroring out if
a user uses a newer LLVM version is too aggressive.

Fixes #25915

(cherry picked from commit 50842f83f467ff54dd22470559a7af79d2025c03)

59bd53bf

by Teo Camarasu at 2025-09-12T17:02:17+05:30

rts: spin if we see a WHITEHOLE in messageBlackHole

When a BLACKHOLE gets cancelled in raiseAsync, we indirect to a THUNK.
GC can then shortcut this, replacing our BLACKHOLE with a fresh THUNK.

This THUNK is not guaranteed to have a valid indirectee field.

If at the same time, a message intended for the previous BLACKHOLE is
processed and concurrently we BLACKHOLE the THUNK, thus temporarily
turning it into a WHITEHOLE, we can get a segfault, since we look at the
undefined indirectee field of the THUNK

The fix is simple: spin if we see a WHITEHOLE, and it will soon be
replaced with a valid BLACKHOLE.

Resolves #26205

(cherry picked from commit 4021181ee0860aca2054883a531f3312361cc701)

ab2932da

by Teo Camarasu at 2025-09-12T17:02:17+05:30

rts: ensure MessageBlackHole.link is always a valid closure

We turn a MessageBlackHole into an StgInd in wakeBlockingQueue().
Therefore it's important that the link field, which becomes the
indirection field, always points to a valid closure.

It's unclear whether it's currently possible for the previous behaviour
to lead to a crash, but it's good to be consistent about this invariant nonetheless.

Co-authored-by: Andreas Klebinger <klebinger.andreas@gmx.at>
(cherry picked from commit a8b2fbae6bcf20bc2f3fe58803096d2a9c5fc43d)

91b7ffbc

by Reed Mullanix at 2025-09-12T17:02:17+05:30

ghc-internal: Fix naturalAndNot for NB/NS case

When the first argument to `naturalAndNot` is larger than a `Word` and the second is `Word`-sized, `naturalAndNot` will truncate the
result:

```
>>> naturalAndNot ((2 ^ 65) .|. (2 ^ 3)) (2 ^ 3)
0
```

In contrast, `naturalAndNot` does not truncate when both arguments are larger than a `Word`, so this appears to be a bug.
Luckily, the fix is pretty easy: we just need to call `bigNatAndNotWord#` instead of truncating.

Fixes #26230

(cherry picked from commit a766286fe759251eceb304c54ba52841c2a51f86)

49148aae

by Ben Gamari at 2025-09-12T17:02:17+05:30

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.

(cherry picked from commit 6e67fa083a50684e1cfae546e07cab4d4250e871)

1b00a659

by Brandon Chinn at 2025-09-12T17:02:17+05:30

Fix for alex-3.5.2.0 (#25623)

This INLINE pragma for alexScanUser was added in 9.12, but then I
ported the change to alex in 3.5.2.0
(https://github.com/haskell/alex/pull/262).

I didn't realize that GHC errors on duplicate INLINE pragmas, so
this ended up being a breaking change.

This change should be backported into 9.12

(cherry picked from commit a1d923786baed5b001c523fd2a76f133be510b04)

c389589b

by Luite Stegeman at 2025-09-12T17:02:17+05:30

Add flags for switching off speculative evaluation.

We found that speculative evaluation can increase the amount of
allocations in some circumstances. This patch adds new flags for
selectively disabling speculative evaluation, allowing us to
test the effect of the optimization.

The new flags are:

  -fspec-eval
     globally enable speculative evaluation

  -fspec-eval-dictfun
     enable speculative evaluation for dictionary functions (no effect
     if speculative evaluation is globally disabled)

The new flags are on by default for all optimisation levels.

See #25284

(cherry picked from commit 2309975247543a4f77009ea5c3c7a8ebe06dc60b)

95b15c15
by Zubin Duggal at 2025-09-12T17:02:17+05:30
```
Prepare 9.12.3
```

23 changed files:

compiler/GHC/CmmToLlvm/Base.hs
compiler/GHC/CoreToStg/Prep.hs
compiler/GHC/Driver/Errors/Ppr.hs
compiler/GHC/Parser/Lexer.x
compiler/GHC/Tc/Solver/Equality.hs
configure.ac
docs/users_guide/9.12.3-notes.rst
libraries/base/changelog.md
libraries/ghc-bignum/changelog.md
libraries/ghc-bignum/src/GHC/Num/Natural.hs
rts/Messages.c
rts/StgMiscClosures.cmm
rts/Updates.h
testsuite/driver/testlib.py
+ testsuite/tests/numeric/should_run/T26230.hs
+ testsuite/tests/numeric/should_run/T26230.stdout
testsuite/tests/numeric/should_run/all.T
+ testsuite/tests/partial-sigs/should_compile/T26256.hs
+ testsuite/tests/partial-sigs/should_compile/T26256.stderr
testsuite/tests/partial-sigs/should_compile/all.T
testsuite/tests/polykinds/T14172.stderr
+ testsuite/tests/typecheck/should_compile/T26256a.hs
testsuite/tests/typecheck/should_compile/all.T

Changes:

compiler/GHC/CmmToLlvm/Base.hs

@@ -526,10 +526,10 @@ generateExternDecls = do
    modifyEnv $ \env -> env { envAliases = emptyUniqSet }
    return (concat defss, [])
 --- | Is a variable one of the special @$llvm@ globals?
 +-- | Is a variable one of the special @\@llvm@ globals?
  isBuiltinLlvmVar :: LlvmVar -> Bool
  isBuiltinLlvmVar (LMGlobalVar lbl _ _ _ _ _) =
 -    "$llvm" `isPrefixOf` unpackFS lbl
 +    "llvm." `isPrefixOf` unpackFS lbl
  isBuiltinLlvmVar _ = False
  -- | Here we take a global variable definition, rename it with a

compiler/GHC/CoreToStg/Prep.hs

@@ -2218,6 +2218,7 @@ mkNonRecFloat env is_unlifted bndr rhs
      is_hnf      = exprIsHNF rhs
      dmd         = idDemandInfo bndr
      is_strict   = isStrUsedDmd dmd
++
      ok_for_spec = exprOkForSpecEval call_ok_for_spec rhs
      -- See Note [Controlling Speculative Evaluation]
      call_ok_for_spec x

compiler/GHC/Driver/Errors/Ppr.hs

@@ -276,7 +276,7 @@ instance Diagnostic DriverMessage where
              ++ llvmVersionStr supportedLlvmVersionLowerBound
              ++ " and "
              ++ llvmVersionStr supportedLlvmVersionUpperBound
 -            ++ ") and reinstall GHC to make -fllvm work")
 +            ++ ") and reinstall GHC to ensure -fllvm works")
    diagnosticReason = \case
      DriverUnknownMessage m
@@ -347,7 +347,7 @@ instance Diagnostic DriverMessage where
      DriverInstantiationNodeInDependencyGeneration {}
        -> ErrorWithoutFlag
      DriverNoConfiguredLLVMToolchain
 -      -> ErrorWithoutFlag
 +      -> WarningWithoutFlag
    diagnosticHints = \case
      DriverUnknownMessage m

compiler/GHC/Parser/Lexer.x

@@ -41,6 +41,7 @@
  -- Alex "Haskell code fragment top"
+ {
 +{-# LANGUAGE CPP #-}
  {-# LANGUAGE ViewPatterns #-}
  {-# LANGUAGE LambdaCase #-}
  {-# LANGUAGE MultiWayIf #-}
@@ -3370,11 +3371,15 @@ topNoLayoutContainsCommas [] = False
  topNoLayoutContainsCommas (ALRLayout _ _ : ls) = topNoLayoutContainsCommas ls
  topNoLayoutContainsCommas (ALRNoLayout b _ : _) = b
 +#ifdef MIN_TOOL_VERSION_alex
 +#if !MIN_TOOL_VERSION_alex(3,5,2)
  -- If the generated alexScan/alexScanUser functions are called multiple times
  -- in this file, alexScanUser gets broken out into a separate function and
  -- increases memory usage. Make sure GHC inlines this function and optimizes it.
  -- https://github.com/haskell/alex/pull/262
  {-# INLINE alexScanUser #-}
 +#endif
 +#endif
  lexToken :: P (PsLocated Token)
  lexToken = do

compiler/GHC/Tc/Solver/Equality.hs

@@ -193,12 +193,8 @@ zonkEqTypes ev eq_rel ty1 ty2
          then tycon tc1 tys1 tys2
          else bale_out ty1 ty2
 -    go ty1 ty2
 -      | Just (ty1a, ty1b) <- tcSplitAppTyNoView_maybe ty1
 -      , Just (ty2a, ty2b) <- tcSplitAppTyNoView_maybe ty2
 -      = do { res_a <- go ty1a ty2a
 -           ; res_b <- go ty1b ty2b
 -           ; return $ combine_rev mkAppTy res_b res_a }
 +    -- If you are temppted to add a case for AppTy/AppTy, be careful
 +    -- See Note [zonkEqTypes and the PKTI]
      go ty1@(LitTy lit1) (LitTy lit2)
        | lit1 == lit2
@@ -274,6 +270,32 @@ zonkEqTypes ev eq_rel ty1 ty2
      combine_rev f (Right tys) (Right ty) = Right (f ty tys)
 +{- Note [zonkEqTypes and the PKTI]
 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 +Because `zonkEqTypes` does /partial/ zonking, we need to be very careful
 +to maintain the Purely Kinded Type Invariant: see GHC.Tc.Gen/HsType
 +HsNote [The Purely Kinded Type Invariant (PKTI)].
++
 +In #26256 we try to solve this equality constraint:
 +   Int :-> Maybe Char ~# k0 Int (m0 Char)
 +where m0 and k0 are unification variables, and
 +   m0 :: Type -> Type
 +It happens that m0 was already unified
 +   m0 := (w0 :: kappa)
 +where kappa is another unification variable that is also already unified:
 +   kappa := Type->Type.
 +So the original type satisifed the PKTI, but a partially-zonked form
 +   k0 Int (w0 Char)
 +does not!! (This a bit reminiscent of Note [mkAppTyM].)
++
 +The solution I have adopted is simply to make `zonkEqTypes` bale out on `AppTy`.
 +After all, it's only supposed to be a quick hack to see if two types are already
 +equal; if we bale out we'll just get into the "proper" canonicaliser.
++
 +The only tricky thing about this approach is that it relies on /omitting/
 +code -- for the AppTy/AppTy case!  Hence this Note
 +-}
++
  {- *********************************************************************
  *                                                                      *
  *           canonicaliseEquality

configure.ac

@@ -22,7 +22,7 @@ AC_INIT([The Glorious Glasgow Haskell Compilation System], [9.12.2], [glasgow-ha
  AC_CONFIG_MACRO_DIRS([m4])
  # Set this to YES for a released version, otherwise NO
 -: ${RELEASE=YES}
 +: ${RELEASE=NO}
  # The primary version (e.g. 7.5, 7.4.1) is set in the AC_INIT line
  # above.  If this is not a released version, then we will append the

docs/users_guide/9.12.3-notes.rst

@@ -13,6 +13,83 @@ Compiler
  - Fixed re-exports of ``MkSolo`` and ``MkSolo#`` (:ghc-ticket:`25182`)
  - Fixed the behavior of ``Language.Haskell.TH.mkName "FUN"`` (:ghc-ticket:`25174`)
 +- Fixed miscompilation involving ``zonkEqTypes`` on ``AppTy/AppTy`` (:ghc-ticket:`26256`)
 +- Fixed CprAnal to detect recursive newtypes (:ghc-ticket:`25944`)
 +- Fixed specialisation of incoherent instances (:ghc-ticket:`25883`)
 +- Fixed bytecode generation for ``tagToEnum# <LITERAL>`` (:ghc-ticket:`25975`)
 +- Fixed panic with EmptyCase and RequiredTypeArguments (:ghc-ticket:`25004`)
 +- Fixed ``tyConStupidTheta`` to handle ``PromotedDataCon`` (:ghc-ticket:`25739`)
 +- Fixed unused import warnings for duplicate record fields (:ghc-ticket:`24035`)
 +- Fixed lexing of ``"\^\"`` (:ghc-ticket:`25937`)
 +- Fixed string gap collapsing (:ghc-ticket:`25784`)
 +- Fixed lexing of comments in multiline strings (:ghc-ticket:`25609`)
 +- Made unexpected LLVM versions a warning rather than an error (:ghc-ticket:`25915`)
 +- Disabled ``-fprof-late-overloaded-calls`` for join points to avoid invalid transformations
 +- Fixed bugs in ``integerRecipMod`` and ``integerPowMod`` (:ghc-ticket:`26017`)
 +- Fixed ``naturalAndNot`` for NB/NS case (:ghc-ticket:`26230`)
 +- Fixed ``ds_ev_typeable`` to use ``mkTrAppChecked`` (:ghc-ticket:`25998`)
 +- Fixed GHC settings to always unescape escaped spaces (:ghc-ticket:`25204`)
 +- Fixed issue with HasCallStack constraint caching (:ghc-ticket:`25529`)
 +- Fixed archive member size writing logic in ``GHC.SysTools.Ar`` (:ghc-ticket:`26120`, :ghc-ticket:`22586`)
++
 +Runtime System
 +~~~~~~~~~~~~~~
++
 +- Fixed ``MessageBlackHole.link`` to always be a valid closure
 +- Fixed handling of WHITEHOLE in ``messageBlackHole`` (:ghc-ticket:`26205`)
 +- Fixed ``rts_clearMemory`` logic when sanity checks are enabled (:ghc-ticket:`26011`)
 +- Fixed underflow frame lookups in the bytecode interpreter (:ghc-ticket:`25750`)
 +- Fixed overflows and reentrancy in interpreter statistics calculation (:ghc-ticket:`25756`)
 +- Fixed INTERP_STATS profiling code (:ghc-ticket:`25695`)
 +- Removed problematic ``n_free`` variable from nonmovingGC (:ghc-ticket:`26186`)
 +- Fixed incorrect format specifiers in era profiling
 +- Improved documentation of SLIDE and PACK bytecode instructions
 +- Eliminated redundant ``SLIDE x 0`` bytecode instructions
 +- Fixed compile issues on powerpc64 ELF v1
++
 +Code Generation
 +~~~~~~~~~~~~~~~
++
 +- Fixed LLVM built-in variable predicate (was checking ``$llvm`` instead of ``@llvm``)
 +- Fixed linkage of built-in arrays for LLVM (:ghc-ticket:`25769`)
 +- Fixed code generation for SSE vector operations (:ghc-ticket:`25859`)
 +- Fixed ``bswap64`` code generation on i386 (:ghc-ticket:`25601`)
 +- Fixed sub-word arithmetic right shift on AArch64 (:ghc-ticket:`26061`)
 +- Fixed LLVM vector literal emission to include type information
 +- Fixed LLVM version detection
 +- Fixed typo in ``padLiveArgs`` that caused segfaults (:ghc-ticket:`25770`, :ghc-ticket:`25773`)
 +- Fixed constant-folding for Word->Float bitcasts
 +- Added surface syntax for Word/Float bitcast operations
 +- Fixed ``MOVD`` format in x86 NCG for ``unpackInt64X2#``
 +- Added ``-finter-module-far-jumps`` flag for AArch64
 +- Fixed RV64 J instruction handling for non-local jumps (:ghc-ticket:`25738`)
 +- Reapplied division by constants optimization
 +- Fixed TNTC to set CmmProc entry_label properly (:ghc-ticket:`25565`)
++
 +Linker
 +~~~~~~
++
 +- Improved efficiency of proddable blocks structure (:ghc-ticket:`26009`)
 +- Fixed Windows DLL loading to avoid redundant ``LoadLibraryEx`` calls (:ghc-ticket:`26009`)
 +- Fixed incorrect use of ``break`` in nested for loop (:ghc-ticket:`26052`)
 +- Fixed linker to not fail due to ``RTLD_NOW`` (:ghc-ticket:`25943`)
 +- Dropped obsolete Windows XP compatibility checks
++
 +GHCi
 +~~~~
++
 +- Fixed ``mkTopLevEnv`` to use ``loadInterfaceForModule`` instead of ``loadSrcInterface`` (:ghc-ticket:`25951`)
++
 +Template Haskell
 +~~~~~~~~~~~~~~~~
++
 +- Added explicit export lists to all remaining template-haskell modules
++
 +Build system
 +~~~~~~~~~~~~~~~~
++
 +- Exposed all of Backtraces' internals for ghc-internal (:ghc-ticket:`26049`)
 +- Fixed cross-compilation configuration override (:ghc-ticket:`26236`)
  Included libraries
  ~~~~~~~~~~~~~~~~~~

libraries/base/changelog.md

  # Changelog for [`base` package](http://hackage.haskell.org/package/base)
 +## 4.21.2.0 *Sept 2024*
 +  * Fix bug where `naturalAndNot` was incorrectly truncating results ([CLC proposal #350](github.com/haskell/core-libraries-committee/issues/350))
++
  ## 4.21.1.0 *Sept 2024*
    * Fix incorrect results of `integerPowMod` when the base is 0 and the exponent is negative, and `integerRecipMod` when the modulus is zero ([#26017](https://gitlab.haskell.org/ghc/ghc/-/issues/26017)).

libraries/ghc-bignum/changelog.md

@@ -4,6 +4,7 @@
  - Expose backendName
  - Add `naturalSetBit[#]` (#21173), `naturalClearBit[#]` (#21175), `naturalComplementBit[#]` (#21181)
 +- Fix bug where `naturalAndNot` was incorrectly truncating results (#26230)
  ## 1.2

libraries/ghc-bignum/src/GHC/Num/Natural.hs

@@ -488,7 +488,7 @@ naturalAndNot :: Natural -> Natural -> Natural
  {-# NOINLINE naturalAndNot #-}
  naturalAndNot (NS n) (NS m) = NS (n `and#` not# m)
  naturalAndNot (NS n) (NB m) = NS (n `and#` not# (bigNatToWord# m))
 -naturalAndNot (NB n) (NS m) = NS (bigNatToWord# n `and#` not# m)
 +naturalAndNot (NB n) (NS m) = NB (bigNatAndNotWord# n m)
  naturalAndNot (NB n) (NB m) = naturalFromBigNat# (bigNatAndNot n m)
  naturalOr :: Natural -> Natural -> Natural

rts/Messages.c

@@ -180,13 +180,22 @@ uint32_t messageBlackHole(Capability *cap, MessageBlackHole *msg)
          bh_info != &stg_CAF_BLACKHOLE_info &&
          bh_info != &__stg_EAGER_BLACKHOLE_info &&
          bh_info != &stg_WHITEHOLE_info) {
 -        // if it is a WHITEHOLE, then a thread is in the process of
 -        // trying to BLACKHOLE it.  But we know that it was once a
 -        // BLACKHOLE, so there is at least a valid pointer in the
 -        // payload, so we can carry on.
          return 0;
+     }
 +    // If we see a WHITEHOLE then we should wait for it to turn into a BLACKHOLE.
 +    // Otherwise we might look at the indirectee and segfault.
 +    // See "Exception handling" in Note [Thunks, blackholes, and indirections]
 +    // We might be looking at a *fresh* THUNK being WHITEHOLE-d so we can't
 +    // guarantee that the indirectee is a valid pointer.
 +#if defined(THREADED_RTS)
 +    if (bh_info == &stg_WHITEHOLE_info) {
 +      while(ACQUIRE_LOAD(&bh->header.info) == &stg_WHITEHOLE_info) {
 +        busy_wait_nop();
 +      }
 +    }
 +#endif
++
      // The blackhole must indirect to a TSO, a BLOCKING_QUEUE, an IND,
      // or a value.
      StgClosure *p;

rts/StgMiscClosures.cmm

@@ -31,6 +31,7 @@ import CLOSURE ENT_VIA_NODE_ctr;
  import CLOSURE RtsFlags;
  import CLOSURE stg_BLOCKING_QUEUE_CLEAN_info;
  import CLOSURE stg_BLOCKING_QUEUE_DIRTY_info;
 +import CLOSURE stg_END_TSO_QUEUE_closure;
  import CLOSURE stg_IND_info;
  import CLOSURE stg_MSG_BLACKHOLE_info;
  import CLOSURE stg_TSO_info;
@@ -574,6 +575,9 @@ retry:
          MessageBlackHole_tso(msg) = CurrentTSO;
          MessageBlackHole_bh(msg) = node;
 +        // Ensure that the link field is a valid closure,
 +        // since we might turn this into an indirection in wakeBlockingQueue()
 +        MessageBlackHole_link(msg) = stg_END_TSO_QUEUE_closure;
          SET_HDR(msg, stg_MSG_BLACKHOLE_info, CCS_SYSTEM);
          // messageBlackHole has appropriate memory barriers when this object is exposed.
          // See Note [Heap memory barriers].

rts/Updates.h

@@ -333,6 +333,10 @@
   * `AP_STACK` closure recording the aborted execution state.
   * See `RaiseAsync.c:raiseAsync` for details.
+  *
 + * This can combine with indirection shortcutting during GC to replace a BLACKHOLE
 + * with a fresh THUNK. We should be very careful here since the THUNK will have an
 + * undefined value in the indirectee field. Looking at the indirectee field can then
 + * lead to a segfault such as #26205.
+  *
   * CAFs
   * ----

testsuite/driver/testlib.py

@@ -1725,7 +1725,7 @@ async def do_test(name: TestName,
          dst_makefile = in_testdir('Makefile')
          if src_makefile.exists():
              makefile = src_makefile.read_text(encoding='UTF-8')
 -            makefile = re.sub('TOP=.*', 'TOP=%s' % config.top, makefile, 1)
 +            makefile = re.sub('TOP=.*', 'TOP=%s' % config.top, makefile, count=1)
              dst_makefile.write_text(makefile, encoding='UTF-8')
      if opts.pre_cmd:

testsuite/tests/numeric/should_run/T26230.hs

 +import Data.Bits
 +import GHC.Num.Natural
++
 +main = do
 +  print $ naturalAndNot ((2 ^ 4) .|. (2 ^ 3)) (2 ^ 3)
 +  print $ naturalAndNot ((2 ^ 129) .|. (2 ^ 65)) (2 ^ 65)
 +  print $ naturalAndNot ((2 ^ 4) .|. (2 ^ 3)) ((2 ^ 65) .|. (2 ^ 3))
 +  print $ naturalAndNot ((2 ^ 65) .|. (2 ^ 3)) (2 ^ 3)

testsuite/tests/numeric/should_run/T26230.stdout

 +16
 +680564733841876926926749214863536422912
 +16
 +36893488147419103232

testsuite/tests/numeric/should_run/all.T

@@ -87,3 +87,4 @@ test('T24066', normal, compile_and_run, [''])
  test('div01', normal, compile_and_run, [''])
  test('T24245', normal, compile_and_run, [''])
  test('T25653', normal, compile_and_run, [''])
 +test('T26230', normal, compile_and_run, [''])

testsuite/tests/partial-sigs/should_compile/T26256.hs

 +{-# LANGUAGE GHC2021 #-}
 +{-# LANGUAGE TypeFamilies #-}
 +{-# LANGUAGE PartialTypeSignatures #-}
++
 +module M (go) where
++
 +import Data.Kind
++
 +type Apply :: (Type -> Type) -> Type
 +data Apply m
++
 +type (:->) :: Type -> Type -> Type
 +type family (:->) where (:->) = (->)
++
 +f :: forall (k :: Type -> Type -> Type) (m :: Type -> Type).
 +     k Int (m Char) -> k Bool (Apply m)
 +f = f
++
 +x :: Int :-> Maybe Char
 +x = x
++
 +go :: Bool -> _ _
 +go = f x

testsuite/tests/partial-sigs/should_compile/T26256.stderr

 +T26256.hs:22:15: warning: [GHC-88464] [-Wpartial-type-signatures (in -Wdefault)]
 +    • Found type wildcard ‘_’ standing for ‘Apply :: (* -> *) -> *’
 +    • In the type signature: go :: Bool -> _ _
++
 +T26256.hs:22:17: warning: [GHC-88464] [-Wpartial-type-signatures (in -Wdefault)]
 +    • Found type wildcard ‘_’ standing for ‘Maybe :: * -> *’
 +    • In the first argument of ‘_’, namely ‘_’
 +      In the type signature: go :: Bool -> _ _

testsuite/tests/partial-sigs/should_compile/all.T

@@ -108,3 +108,4 @@ test('T21667', normal, compile, [''])
  test('T22065', normal, compile, [''])
  test('T16152', normal, compile, [''])
  test('T20076', expect_broken(20076), compile, [''])
 +test('T26256', normal, compile, [''])

testsuite/tests/polykinds/T14172.stderr

  T14172.hs:7:46: error: [GHC-88464]
 -    • Found type wildcard ‘_’ standing for ‘a'1 :: k0’
 -      Where: ‘k0’ is an ambiguous type variable
 +    • Found type wildcard ‘_’ standing for ‘a'1 :: k30’
 +      Where: ‘k30’ is an ambiguous type variable
               ‘a'1’ is an ambiguous type variable
        To use the inferred type, enable PartialTypeSignatures
      • In the first argument of ‘h’, namely ‘_’

testsuite/tests/typecheck/should_compile/T26256a.hs

 +{-# LANGUAGE GHC2021 #-}
 +{-# LANGUAGE TypeFamilies #-}
++
 +module T26256 (go) where
++
 +import Data.Kind
++
 +class Cat k where (<<<) :: k a b -> k x a -> k x b
 +instance Cat (->) where (<<<) = (.)
 +class Pro k p where pro :: k a b s t -> p a b -> p s t
 +data Hiding o a b s t = forall e. Hiding (s -> o e a)
 +newtype Apply e a = Apply (e a)
++
 +type (:->) :: Type -> Type -> Type
 +type family (:->) where
 +  (:->) = (->)
++
 +go :: (Pro (Hiding Apply) p) => (s :-> e a) -> p a b -> p s t
 +go sea = pro (Hiding (Apply <<< sea))

testsuite/tests/typecheck/should_compile/all.T

@@ -935,3 +935,4 @@ test('T24845a', normal, compile, [''])
  test('T23501a', normal, compile, [''])
  test('T23501b', normal, compile, [''])
  test('T25597', normal, compile, [''])
 +test('T26256a', normal, compile, [''])