[Git][ghc/ghc][master] Define type Void# = (# #) (#18441)
Marge Bot
gitlab at gitlab.haskell.org
Thu Jul 23 00:21:59 UTC 2020
Marge Bot pushed to branch master at Glasgow Haskell Compiler / GHC
Commits:
cfa89149 by Krzysztof Gogolewski at 2020-07-22T20:21:48-04:00
Define type Void# = (# #) (#18441)
There's one backwards compatibility issue: GHC.Prim no longer exports
Void#, we now manually re-export it from GHC.Exts.
- - - - -
26 changed files:
- compiler/GHC/Builtin/Names.hs
- compiler/GHC/Builtin/Types.hs
- compiler/GHC/Builtin/Types/Prim.hs
- compiler/GHC/Builtin/primops.txt.pp
- compiler/GHC/Core/Opt/Specialise.hs
- compiler/GHC/Core/Opt/WorkWrap/Utils.hs
- compiler/GHC/CoreToByteCode.hs
- compiler/GHC/HsToCore/Utils.hs
- compiler/GHC/Tc/TyCl/Build.hs
- compiler/GHC/Tc/TyCl/PatSyn.hs
- compiler/GHC/Types/Id/Make.hs
- docs/users_guide/8.12.1-notes.rst
- libraries/base/GHC/Exts.hs
- libraries/base/tests/isValidNatural.hs
- libraries/ghc-bignum/src/GHC/Num/BigNat.hs
- libraries/ghc-bignum/src/GHC/Num/BigNat/Check.hs
- libraries/ghc-bignum/src/GHC/Num/Integer.hs
- libraries/ghc-bignum/src/GHC/Num/Primitives.hs
- libraries/ghc-prim/GHC/Prim/Exception.hs
- libraries/ghc-prim/GHC/Prim/Panic.hs
- libraries/ghc-prim/GHC/Types.hs
- testsuite/tests/codeGen/should_compile/T12115.hs
- testsuite/tests/printer/T18052a.stderr
- testsuite/tests/simplCore/should_compile/T13143.stderr
- testsuite/tests/unboxedsums/ffi1.hs
- utils/genprimopcode/Main.hs
Changes:
=====================================
compiler/GHC/Builtin/Names.hs
=====================================
@@ -1802,7 +1802,7 @@ statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
funPtrTyConKey, tVarPrimTyConKey, eqPrimTyConKey,
- eqReprPrimTyConKey, eqPhantPrimTyConKey, voidPrimTyConKey,
+ eqReprPrimTyConKey, eqPhantPrimTyConKey,
compactPrimTyConKey :: Unique
statePrimTyConKey = mkPreludeTyConUnique 50
stableNamePrimTyConKey = mkPreludeTyConUnique 51
@@ -1812,7 +1812,6 @@ eqReprPrimTyConKey = mkPreludeTyConUnique 54
eqPhantPrimTyConKey = mkPreludeTyConUnique 55
mutVarPrimTyConKey = mkPreludeTyConUnique 56
ioTyConKey = mkPreludeTyConUnique 57
-voidPrimTyConKey = mkPreludeTyConUnique 58
wordPrimTyConKey = mkPreludeTyConUnique 59
wordTyConKey = mkPreludeTyConUnique 60
word8PrimTyConKey = mkPreludeTyConUnique 61
=====================================
compiler/GHC/Builtin/Types.hs
=====================================
@@ -75,6 +75,7 @@ module GHC.Builtin.Types (
promotedTupleDataCon,
unitTyCon, unitDataCon, unitDataConId, unitTy, unitTyConKey,
pairTyCon,
+ unboxedUnitTy,
unboxedUnitTyCon, unboxedUnitDataCon,
unboxedTupleKind, unboxedSumKind,
@@ -1053,6 +1054,9 @@ unitDataConId = dataConWorkId unitDataCon
pairTyCon :: TyCon
pairTyCon = tupleTyCon Boxed 2
+unboxedUnitTy :: Type
+unboxedUnitTy = mkTyConApp unboxedUnitTyCon []
+
unboxedUnitTyCon :: TyCon
unboxedUnitTyCon = tupleTyCon Unboxed 0
=====================================
compiler/GHC/Builtin/Types/Prim.hs
=====================================
@@ -45,7 +45,6 @@ module GHC.Builtin.Types.Prim(
floatPrimTyCon, floatPrimTy, floatPrimTyConName,
doublePrimTyCon, doublePrimTy, doublePrimTyConName,
- voidPrimTyCon, voidPrimTy,
statePrimTyCon, mkStatePrimTy,
realWorldTyCon, realWorldTy, realWorldStatePrimTy,
@@ -180,7 +179,6 @@ exposedPrimTyCons
, stableNamePrimTyCon
, compactPrimTyCon
, statePrimTyCon
- , voidPrimTyCon
, proxyPrimTyCon
, threadIdPrimTyCon
, wordPrimTyCon
@@ -209,7 +207,7 @@ mkBuiltInPrimTc fs unique tycon
BuiltInSyntax
-charPrimTyConName, intPrimTyConName, int8PrimTyConName, int16PrimTyConName, int32PrimTyConName, int64PrimTyConName, wordPrimTyConName, word32PrimTyConName, word8PrimTyConName, word16PrimTyConName, word64PrimTyConName, addrPrimTyConName, floatPrimTyConName, doublePrimTyConName, statePrimTyConName, proxyPrimTyConName, realWorldTyConName, arrayPrimTyConName, arrayArrayPrimTyConName, smallArrayPrimTyConName, byteArrayPrimTyConName, mutableArrayPrimTyConName, mutableByteArrayPrimTyConName, mutableArrayArrayPrimTyConName, smallMutableArrayPrimTyConName, mutVarPrimTyConName, mVarPrimTyConName, ioPortPrimTyConName, tVarPrimTyConName, stablePtrPrimTyConName, stableNamePrimTyConName, compactPrimTyConName, bcoPrimTyConName, weakPrimTyConName, threadIdPrimTyConName, eqPrimTyConName, eqReprPrimTyConName, eqPhantPrimTyConName, voidPrimTyConName :: Name
+charPrimTyConName, intPrimTyConName, int8PrimTyConName, int16PrimTyConName, int32PrimTyConName, int64PrimTyConName, wordPrimTyConName, word32PrimTyConName, word8PrimTyConName, word16PrimTyConName, word64PrimTyConName, addrPrimTyConName, floatPrimTyConName, doublePrimTyConName, statePrimTyConName, proxyPrimTyConName, realWorldTyConName, arrayPrimTyConName, arrayArrayPrimTyConName, smallArrayPrimTyConName, byteArrayPrimTyConName, mutableArrayPrimTyConName, mutableByteArrayPrimTyConName, mutableArrayArrayPrimTyConName, smallMutableArrayPrimTyConName, mutVarPrimTyConName, mVarPrimTyConName, ioPortPrimTyConName, tVarPrimTyConName, stablePtrPrimTyConName, stableNamePrimTyConName, compactPrimTyConName, bcoPrimTyConName, weakPrimTyConName, threadIdPrimTyConName, eqPrimTyConName, eqReprPrimTyConName, eqPhantPrimTyConName :: Name
charPrimTyConName = mkPrimTc (fsLit "Char#") charPrimTyConKey charPrimTyCon
intPrimTyConName = mkPrimTc (fsLit "Int#") intPrimTyConKey intPrimTyCon
int8PrimTyConName = mkPrimTc (fsLit "Int8#") int8PrimTyConKey int8PrimTyCon
@@ -225,7 +223,6 @@ addrPrimTyConName = mkPrimTc (fsLit "Addr#") addrPrimTyConKey addrPr
floatPrimTyConName = mkPrimTc (fsLit "Float#") floatPrimTyConKey floatPrimTyCon
doublePrimTyConName = mkPrimTc (fsLit "Double#") doublePrimTyConKey doublePrimTyCon
statePrimTyConName = mkPrimTc (fsLit "State#") statePrimTyConKey statePrimTyCon
-voidPrimTyConName = mkPrimTc (fsLit "Void#") voidPrimTyConKey voidPrimTyCon
proxyPrimTyConName = mkPrimTc (fsLit "Proxy#") proxyPrimTyConKey proxyPrimTyCon
eqPrimTyConName = mkPrimTc (fsLit "~#") eqPrimTyConKey eqPrimTyCon
eqReprPrimTyConName = mkBuiltInPrimTc (fsLit "~R#") eqReprPrimTyConKey eqReprPrimTyCon
@@ -897,12 +894,6 @@ realWorldStatePrimTy = mkStatePrimTy realWorldTy -- State# RealWorld
-- so they are defined in \tr{GHC.Builtin.Types}, not here.
-voidPrimTy :: Type
-voidPrimTy = TyConApp voidPrimTyCon []
-
-voidPrimTyCon :: TyCon
-voidPrimTyCon = pcPrimTyCon voidPrimTyConName [] VoidRep
-
mkProxyPrimTy :: Type -> Type -> Type
mkProxyPrimTy k ty = TyConApp proxyPrimTyCon [k, ty]
=====================================
compiler/GHC/Builtin/primops.txt.pp
=====================================
@@ -3355,8 +3355,6 @@ section "Misc"
{These aren't nearly as wired in as Etc...}
------------------------------------------------------------------------
-primtype Void#
-
primop GetCCSOfOp "getCCSOf#" GenPrimOp
a -> State# s -> (# State# s, Addr# #)
=====================================
compiler/GHC/Core/Opt/Specialise.hs
=====================================
@@ -39,7 +39,7 @@ import GHC.Core.Opt.Arity ( etaExpandToJoinPointRule )
import GHC.Types.Unique.Supply
import GHC.Types.Name
import GHC.Types.Id.Make ( voidArgId, voidPrimId )
-import GHC.Builtin.Types.Prim ( voidPrimTy )
+import GHC.Builtin.Types ( unboxedUnitTy )
import GHC.Data.Maybe ( mapMaybe, maybeToList, isJust )
import GHC.Utils.Monad ( foldlM )
import GHC.Types.Basic
@@ -1427,7 +1427,7 @@ specCalls mb_mod env existing_rules calls_for_me fn rhs
(spec_bndrs, spec_rhs, spec_fn_ty)
| add_void_arg = ( voidPrimId : spec_bndrs1
, Lam voidArgId spec_rhs1
- , mkVisFunTyMany voidPrimTy spec_fn_ty1)
+ , mkVisFunTyMany unboxedUnitTy spec_fn_ty1)
| otherwise = (spec_bndrs1, spec_rhs1, spec_fn_ty1)
join_arity_decr = length rule_lhs_args - length spec_bndrs
=====================================
compiler/GHC/Core/Opt/WorkWrap/Utils.hs
=====================================
@@ -28,8 +28,7 @@ import GHC.Types.Cpr
import GHC.Core.Make ( mkAbsentErrorApp, mkCoreUbxTup
, mkCoreApp, mkCoreLet )
import GHC.Types.Id.Make ( voidArgId, voidPrimId )
-import GHC.Builtin.Types ( tupleDataCon )
-import GHC.Builtin.Types.Prim ( voidPrimTy )
+import GHC.Builtin.Types ( tupleDataCon, unboxedUnitTy )
import GHC.Types.Literal ( absentLiteralOf, rubbishLit )
import GHC.Types.Var.Env ( mkInScopeSet )
import GHC.Types.Var.Set ( VarSet )
@@ -1256,7 +1255,7 @@ mk_absent_let dflags fam_envs arg
| Just tc <- tyConAppTyCon_maybe nty
, Just lit <- absentLiteralOf tc
= Just (Let (NonRec arg (Lit lit `mkCast` mkSymCo co)))
- | nty `eqType` voidPrimTy
+ | nty `eqType` unboxedUnitTy
= Just (Let (NonRec arg (Var voidPrimId `mkCast` mkSymCo co)))
| otherwise
= WARN( True, text "No absent value for" <+> ppr arg_ty )
=====================================
compiler/GHC/CoreToByteCode.hs
=====================================
@@ -43,6 +43,7 @@ import GHC.Core.DataCon
import GHC.Core.TyCon
import GHC.Utils.Misc
import GHC.Types.Var.Set
+import GHC.Builtin.Types ( unboxedUnitTy )
import GHC.Builtin.Types.Prim
import GHC.Core.TyCo.Ppr ( pprType )
import GHC.Utils.Error
@@ -673,7 +674,7 @@ schemeE d s p (AnnCase scrut bndr _ alt@[(DEFAULT, [], _)])
| isUnboxedTupleType (idType bndr)
, Just ty <- case typePrimRep (idType bndr) of
[_] -> Just (unwrapType (idType bndr))
- [] -> Just voidPrimTy
+ [] -> Just unboxedUnitTy
_ -> Nothing
-- handles any pattern with a single non-void binder; in particular I/O
-- monad returns (# RealWorld#, a #)
@@ -708,7 +709,7 @@ protectNNLJoinPointBind x rhs@(fvs, _)
protectNNLJoinPointId :: Id -> Id
protectNNLJoinPointId x
= ASSERT( isNNLJoinPoint x )
- updateIdTypeButNotMult (voidPrimTy `mkVisFunTyMany`) x
+ updateIdTypeButNotMult (unboxedUnitTy `mkVisFunTyMany`) x
{-
Ticked Expressions
@@ -743,8 +744,8 @@ isUnliftedType check in the AnnVar case of schemeE.) Here is the strategy:
1. Detect NNLJPs. This is done in isNNLJoinPoint.
-2. When binding an NNLJP, add a `\ (_ :: Void#) ->` to its RHS, and modify the
- type to tack on a `Void# ->`. (Void# is written voidPrimTy within GHC.)
+2. When binding an NNLJP, add a `\ (_ :: (# #)) ->` to its RHS, and modify the
+ type to tack on a `(# #) ->`.
Note that functions are never levity-polymorphic, so this transformation
changes an NNLJP to a non-levity-polymorphic join point. This is done
in protectNNLJoinPointBind, called from the AnnLet case of schemeE.
=====================================
compiler/GHC/HsToCore/Utils.hs
=====================================
@@ -67,7 +67,6 @@ import GHC.Core.DataCon
import GHC.Core.PatSyn
import GHC.Core.Type
import GHC.Core.Coercion
-import GHC.Builtin.Types.Prim
import GHC.Builtin.Types
import GHC.Types.Basic
import GHC.Core.ConLike
@@ -853,8 +852,8 @@ mkFailurePair :: CoreExpr -- Result type of the whole case expression
CoreExpr) -- Fail variable applied to realWorld#
-- See Note [Failure thunks and CPR]
mkFailurePair expr
- = do { fail_fun_var <- newFailLocalDs Many (voidPrimTy `mkVisFunTyMany` ty)
- ; fail_fun_arg <- newSysLocalDs Many voidPrimTy
+ = do { fail_fun_var <- newFailLocalDs Many (unboxedUnitTy `mkVisFunTyMany` ty)
+ ; fail_fun_arg <- newSysLocalDs Many unboxedUnitTy
; let real_arg = setOneShotLambda fail_fun_arg
; return (NonRec fail_fun_var (Lam real_arg expr),
App (Var fail_fun_var) (Var voidPrimId)) }
=====================================
compiler/GHC/Tc/TyCl/Build.hs
=====================================
@@ -21,8 +21,7 @@ import GHC.Prelude
import GHC.Iface.Env
import GHC.Core.FamInstEnv( FamInstEnvs, mkNewTypeCoAxiom )
-import GHC.Builtin.Types( isCTupleTyConName )
-import GHC.Builtin.Types.Prim ( voidPrimTy )
+import GHC.Builtin.Types( isCTupleTyConName, unboxedUnitTy )
import GHC.Core.DataCon
import GHC.Core.PatSyn
import GHC.Types.Var
@@ -209,11 +208,11 @@ buildPatSyn src_name declared_infix matcher@(matcher_id,_) builder
subst = zipTvSubst (univ_tvs1 ++ ex_tvs1)
(mkTyVarTys (binderVars (univ_tvs ++ ex_tvs)))
- -- For a nullary pattern synonym we add a single void argument to the
+ -- For a nullary pattern synonym we add a single (# #) argument to the
-- matcher to preserve laziness in the case of unlifted types.
-- See #12746
compareArgTys :: [Type] -> [Type] -> Bool
- compareArgTys [] [x] = x `eqType` voidPrimTy
+ compareArgTys [] [x] = x `eqType` unboxedUnitTy
compareArgTys arg_tys matcher_arg_tys = arg_tys `eqTypes` matcher_arg_tys
=====================================
compiler/GHC/Tc/TyCl/PatSyn.hs
=====================================
@@ -698,12 +698,12 @@ tcPatSynMatcher (L loc name) lpat
res_ty = mkTyVarTy res_tv
is_unlifted = null args && null prov_dicts
(cont_args, cont_arg_tys)
- | is_unlifted = ([nlHsVar voidPrimId], [voidPrimTy])
+ | is_unlifted = ([nlHsVar voidPrimId], [unboxedUnitTy])
| otherwise = (args, arg_tys)
cont_ty = mkInfSigmaTy ex_tvs prov_theta $
mkVisFunTysMany cont_arg_tys res_ty
- fail_ty = mkVisFunTyMany voidPrimTy res_ty
+ fail_ty = mkVisFunTyMany unboxedUnitTy res_ty
; matcher_name <- newImplicitBinder name mkMatcherOcc
; scrutinee <- newSysLocalId (fsLit "scrut") Many pat_ty
@@ -905,7 +905,7 @@ tcPatSynBuilderOcc ps
add_void :: Bool -> Type -> Type
add_void need_dummy_arg ty
- | need_dummy_arg = mkVisFunTyMany voidPrimTy ty
+ | need_dummy_arg = mkVisFunTyMany unboxedUnitTy ty
| otherwise = ty
tcPatToExpr :: Name -> [Located Name] -> LPat GhcRn
=====================================
compiler/GHC/Types/Id/Make.hs
=====================================
@@ -121,7 +121,7 @@ The ghcPrimIds
but have perfectly reasonable unfoldings in Core
* Either have a CompulsoryUnfolding (hence always inlined), or
- of an EvaldUnfolding and void representation (e.g. void#)
+ of an EvaldUnfolding and void representation (e.g. realWorldPrimId)
* Are (or should be) defined in primops.txt.pp as 'pseudoop'
Reason: that's how we generate documentation for them
@@ -1760,12 +1760,19 @@ realWorldPrimId = pcMiscPrelId realWorldName realWorldStatePrimTy
`setNeverLevPoly` realWorldStatePrimTy)
voidPrimId :: Id -- Global constant :: Void#
-voidPrimId = pcMiscPrelId voidPrimIdName voidPrimTy
- (noCafIdInfo `setUnfoldingInfo` evaldUnfolding -- Note [evaldUnfoldings]
- `setNeverLevPoly` voidPrimTy)
+ -- The type Void# is now the same as (# #) (ticket #18441),
+ -- this identifier just signifies the (# #) datacon
+ -- and is kept for backwards compatibility.
+ -- We cannot define it in normal Haskell, since it's
+ -- a top-level unlifted value.
+voidPrimId = pcMiscPrelId voidPrimIdName unboxedUnitTy
+ (noCafIdInfo `setUnfoldingInfo` mkCompulsoryUnfolding rhs
+ `setNeverLevPoly` unboxedUnitTy)
+ where rhs = Var (dataConWorkId unboxedUnitDataCon)
+
voidArgId :: Id -- Local lambda-bound :: Void#
-voidArgId = mkSysLocal (fsLit "void") voidArgIdKey Many voidPrimTy
+voidArgId = mkSysLocal (fsLit "void") voidArgIdKey Many unboxedUnitTy
coercionTokenId :: Id -- :: () ~ ()
coercionTokenId -- See Note [Coercion tokens] in "GHC.CoreToStg"
=====================================
docs/users_guide/8.12.1-notes.rst
=====================================
@@ -336,6 +336,9 @@ Haddock
- Add a known-key ``cstringLength#`` to ``GHC.CString`` that is eligible
for constant folding by a built-in rule.
+- ``Void#`` is now a type synonym for the unboxed tuple ``(# #)``.
+ Code using ``Void#`` now has to enable :extension:`UnboxedTuples`.
+
``ghc`` library
~~~~~~~~~~~~~~~
=====================================
libraries/base/GHC/Exts.hs
=====================================
@@ -37,6 +37,7 @@ module GHC.Exts
uncheckedShiftL64#, uncheckedShiftRL64#,
uncheckedIShiftL64#, uncheckedIShiftRA64#,
isTrue#,
+ Void#, -- Previously exported by GHC.Prim
-- * Compat wrapper
atomicModifyMutVar#,
=====================================
libraries/base/tests/isValidNatural.hs
=====================================
@@ -1,4 +1,4 @@
-{-# language MagicHash #-}
+{-# language MagicHash, UnboxedTuples #-}
import GHC.Num.Natural
import GHC.Num.BigNat
@@ -7,4 +7,4 @@ import GHC.Exts
main = print $ map naturalCheck [0, 1, maxWord, maxWord + 1, invalid]
where
maxWord = fromIntegral (maxBound :: Word)
- invalid = NB (bigNatOne# void#) -- 1 would fit into the NS constructor.
+ invalid = NB (bigNatOne# (# #)) -- 1 would fit into the NS constructor.
=====================================
libraries/ghc-bignum/src/GHC/Num/BigNat.hs
=====================================
@@ -68,11 +68,11 @@ type BigNat# = WordArray#
-- As a consequence, zero is represented with a WordArray# whose size is 0.
data BigNat = BN# { unBigNat :: BigNat# }
--- Note [Why Void#?]
+-- Note [Why (# #)?]
-- ~~~~~~~~~~~~~~~~~
--
-- We can't have top-level BigNat# for now because they are unlifted ByteArray#
--- (see #17521). So we use functions that take an empty argument Void# that
+-- (see #17521). So we use functions that take an empty argument (# #) that
-- will be discarded at compile time.
@@ -104,18 +104,18 @@ bigNatOne :: BigNat
bigNatOne = BN# (bigNatFromWord# 1##)
-- | BigNat Zero
-bigNatZero# :: Void# -> BigNat# -- cf Note [Why Void#?]
+bigNatZero# :: (# #) -> BigNat# -- cf Note [Why (# #)?]
bigNatZero# _ = case bigNatZero of
BN# w -> w
-- | BigNat one
-bigNatOne# :: Void# -> BigNat# -- cf Note [Why Void#?]
+bigNatOne# :: (# #) -> BigNat# -- cf Note [Why (# #)?]
bigNatOne# _ = case bigNatOne of
BN# w -> w
-raiseDivZero_BigNat :: Void# -> BigNat#
+raiseDivZero_BigNat :: (# #) -> BigNat#
raiseDivZero_BigNat _ = case raiseDivZero of
- !_ -> bigNatZero# void#
+ !_ -> bigNatZero# (# #)
-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives
-- | Indicate if a bigNat is zero
@@ -184,7 +184,7 @@ bigNatFromWord (W# w) = bigNatFromWord# w
-- | Create a BigNat from a Word
bigNatFromWord# :: Word# -> BigNat#
-bigNatFromWord# 0## = bigNatZero# void#
+bigNatFromWord# 0## = bigNatZero# (# #)
bigNatFromWord# w = wordArrayFromWord# w
-- | Convert a list of non-zero Words (most-significant first) into a BigNat
@@ -204,7 +204,7 @@ bigNatFromAbsInt# i = bigNatFromWord# (wordFromAbsInt# i)
-- | Convert a list of non-zero Words (most-significant first) into a BigNat.
-- Don't remove most-significant zero words
bigNatFromWordListUnsafe :: [Word] -> BigNat#
-bigNatFromWordListUnsafe [] = bigNatZero# void#
+bigNatFromWordListUnsafe [] = bigNatZero# (# #)
bigNatFromWordListUnsafe xs =
let
length i [] = i
@@ -227,7 +227,7 @@ bigNatToWordList bn = go (bigNatSize# bn)
-- | Convert two Word# (most-significant first) into a BigNat
bigNatFromWord2# :: Word# -> Word# -> BigNat#
-bigNatFromWord2# 0## 0## = bigNatZero# void#
+bigNatFromWord2# 0## 0## = bigNatZero# (# #)
bigNatFromWord2# 0## n = bigNatFromWord# n
bigNatFromWord2# w1 w2 = wordArrayFromWord2# w1 w2
@@ -415,9 +415,9 @@ bigNatAdd a b
-- | Multiply a BigNat by a Word#
bigNatMulWord# :: BigNat# -> Word# -> BigNat#
bigNatMulWord# a w
- | 0## <- w = bigNatZero# void#
+ | 0## <- w = bigNatZero# (# #)
| 1## <- w = a
- | bigNatIsZero a = bigNatZero# void#
+ | bigNatIsZero a = bigNatZero# (# #)
| bigNatIsOne a = bigNatFromWord# w
| isTrue# (bigNatSize# a ==# 1#)
= case timesWord2# (bigNatIndex# a 0#) w of
@@ -531,7 +531,7 @@ bigNatSub a b
bigNatQuotWord# :: BigNat# -> Word# -> BigNat#
bigNatQuotWord# a b
| 1## <- b = a
- | 0## <- b = raiseDivZero_BigNat void#
+ | 0## <- b = raiseDivZero_BigNat (# #)
| True =
let
sz = wordArraySize# a
@@ -551,7 +551,7 @@ bigNatQuotWord a (W# b) = bigNatQuotWord# a b
-- b /= 0
bigNatRemWord# :: BigNat# -> Word# -> Word#
bigNatRemWord# a b
- | 0## <- b = raiseDivZero_Word# void#
+ | 0## <- b = raiseDivZero_Word# (# #)
| 1## <- b = 0##
| bigNatIsZero a = 0##
| True = inline bignat_rem_word a b
@@ -570,14 +570,14 @@ bigNatRemWord a (W# b) = W# (bigNatRemWord# a b)
bigNatQuotRemWord# :: BigNat# -> Word# -> (# BigNat#, Word# #)
bigNatQuotRemWord# a b
| 0## <- b = case raiseDivZero of
- !_ -> (# bigNatZero# void#, 0## #)
+ !_ -> (# bigNatZero# (# #), 0## #)
-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives
| 1## <- b = (# a, 0## #)
| isTrue# (bigNatSize# a ==# 1#)
, a0 <- indexWordArray# a 0#
= case compareWord# a0 b of
- LT -> (# bigNatZero# void#, a0 #)
- EQ -> (# bigNatOne# void#, 0## #)
+ LT -> (# bigNatZero# (# #), a0 #)
+ EQ -> (# bigNatOne# (# #), 0## #)
GT -> case quotRemWord# a0 b of
(# q, r #) -> (# bigNatFromWord# q, r #)
| True =
@@ -598,12 +598,12 @@ bigNatQuotRemWord# a b
bigNatQuotRem# :: BigNat# -> BigNat# -> (# BigNat#, BigNat# #)
bigNatQuotRem# a b
| bigNatIsZero b = case raiseDivZero of
- !_ -> (# bigNatZero# void#, bigNatZero# void# #)
+ !_ -> (# bigNatZero# (# #), bigNatZero# (# #) #)
-- see Note [ghc-bignum exceptions] in GHC.Num.Primitives
- | bigNatIsZero a = (# bigNatZero# void#, bigNatZero# void# #)
- | bigNatIsOne b = (# a , bigNatZero# void# #)
- | LT <- cmp = (# bigNatZero# void#, a #)
- | EQ <- cmp = (# bigNatOne# void#, bigNatZero# void# #)
+ | bigNatIsZero a = (# bigNatZero# (# #), bigNatZero# (# #) #)
+ | bigNatIsOne b = (# a , bigNatZero# (# #) #)
+ | LT <- cmp = (# bigNatZero# (# #), a #)
+ | EQ <- cmp = (# bigNatOne# (# #), bigNatZero# (# #) #)
| isTrue# (szB ==# 1#) = case bigNatQuotRemWord# a (bigNatIndex# b 0#) of
(# q, r #) -> (# q, bigNatFromWord# r #)
@@ -620,11 +620,11 @@ bigNatQuotRem# a b
-- | BigNat division returning quotient
bigNatQuot :: BigNat# -> BigNat# -> BigNat#
bigNatQuot a b
- | bigNatIsZero b = raiseDivZero_BigNat void#
- | bigNatIsZero a = bigNatZero# void#
+ | bigNatIsZero b = raiseDivZero_BigNat (# #)
+ | bigNatIsZero a = bigNatZero# (# #)
| bigNatIsOne b = a
- | LT <- cmp = bigNatZero# void#
- | EQ <- cmp = bigNatOne# void#
+ | LT <- cmp = bigNatZero# (# #)
+ | EQ <- cmp = bigNatOne# (# #)
| isTrue# (szB ==# 1#) = bigNatQuotWord# a (bigNatIndex# b 0#)
| True = withNewWordArrayTrimed# szQ \mwq s ->
inline bignat_quot mwq a b s
@@ -637,11 +637,11 @@ bigNatQuot a b
-- | BigNat division returning remainder
bigNatRem :: BigNat# -> BigNat# -> BigNat#
bigNatRem a b
- | bigNatIsZero b = raiseDivZero_BigNat void#
- | bigNatIsZero a = bigNatZero# void#
- | bigNatIsOne b = bigNatZero# void#
+ | bigNatIsZero b = raiseDivZero_BigNat (# #)
+ | bigNatIsZero a = bigNatZero# (# #)
+ | bigNatIsOne b = bigNatZero# (# #)
| LT <- cmp = a
- | EQ <- cmp = bigNatZero# void#
+ | EQ <- cmp = bigNatZero# (# #)
| isTrue# (szB ==# 1#) = case bigNatRemWord# a (bigNatIndex# b 0#) of
r -> bigNatFromWord# r
| True = withNewWordArrayTrimed# szR \mwr s ->
@@ -719,8 +719,8 @@ bigNatGcdWord# a b
-- | Least common multiple
bigNatLcm :: BigNat# -> BigNat# -> BigNat#
bigNatLcm a b
- | bigNatIsZero a = bigNatZero# void#
- | bigNatIsZero b = bigNatZero# void#
+ | bigNatIsZero a = bigNatZero# (# #)
+ | bigNatIsZero b = bigNatZero# (# #)
| bigNatIsOne a = b
| bigNatIsOne b = a
| True
@@ -734,8 +734,8 @@ bigNatLcm a b
-- | Least common multiple with a Word#
bigNatLcmWord# :: BigNat# -> Word# -> BigNat#
bigNatLcmWord# a b
- | bigNatIsZero a = bigNatZero# void#
- | 0## <- b = bigNatZero# void#
+ | bigNatIsZero a = bigNatZero# (# #)
+ | 0## <- b = bigNatZero# (# #)
| bigNatIsOne a = bigNatFromWord# b
| 1## <- b = a
| 1# <- bigNatSize# a = bigNatLcmWordWord# (bigNatIndex# a 0#) b
@@ -746,8 +746,8 @@ bigNatLcmWord# a b
-- | Least common multiple between two Word#
bigNatLcmWordWord# :: Word# -> Word# -> BigNat#
bigNatLcmWordWord# a b
- | 0## <- a = bigNatZero# void#
- | 0## <- b = bigNatZero# void#
+ | 0## <- a = bigNatZero# (# #)
+ | 0## <- b = bigNatZero# (# #)
| 1## <- a = bigNatFromWord# b
| 1## <- b = bigNatFromWord# a
| True = case (a `quotWord#` (a `gcdWord#` b)) `timesWord2#` b of
@@ -879,7 +879,7 @@ bigNatShiftR# a n
| nw <- word2Int# (n `uncheckedShiftRL#` WORD_SIZE_BITS_SHIFT#)
, isTrue# (nw >=# wordArraySize# a)
- = bigNatZero# void#
+ = bigNatZero# (# #)
| True
= let
@@ -900,7 +900,7 @@ bigNatShiftRNeg# a n
| nw <- word2Int# (n `uncheckedShiftRL#` WORD_SIZE_BITS_SHIFT#)
, isTrue# (nw >=# wordArraySize# a)
- = bigNatZero# void#
+ = bigNatZero# (# #)
| True
= let
@@ -961,7 +961,7 @@ bigNatTestBit a (W# n) = isTrue# (bigNatTestBit# a n)
--
bigNatBit# :: Word# -> BigNat#
bigNatBit# i
- | 0## <- i = bigNatOne# void#
+ | 0## <- i = bigNatOne# (# #)
| True =
let
!nw = word2Int# (i `uncheckedShiftRL#` WORD_SIZE_BITS_SHIFT#)
@@ -1000,7 +1000,7 @@ bigNatClearBit# a n
| 0## <- nv
, isTrue# (nw +# 1# ==# sz)
-> case sz -# (waClzAt a (sz -# 2#) +# 1#) of
- 0# -> bigNatZero# void#
+ 0# -> bigNatZero# (# #)
nsz -> withNewWordArray# nsz \mwa s ->
mwaArrayCopy# mwa 0# a 0# nsz s
@@ -1060,7 +1060,7 @@ bigNatLog2 a = W# (bigNatLog2# a)
bigNatLogBase# :: BigNat# -> BigNat# -> Word#
bigNatLogBase# base a
| bigNatIsZero base || bigNatIsOne base
- = unexpectedValue_Word# void#
+ = unexpectedValue_Word# (# #)
| 1# <- bigNatSize# base
, 2## <- bigNatIndex# base 0#
@@ -1086,8 +1086,8 @@ bigNatLogBase base a = W# (bigNatLogBase# base a)
-- | Logarithm for an arbitrary base
bigNatLogBaseWord# :: Word# -> BigNat# -> Word#
bigNatLogBaseWord# base a
- | 0## <- base = unexpectedValue_Word# void#
- | 1## <- base = unexpectedValue_Word# void#
+ | 0## <- base = unexpectedValue_Word# (# #)
+ | 1## <- base = unexpectedValue_Word# (# #)
| 2## <- base = bigNatLog2# a
-- TODO: optimize log base power of 2 (256, etc.)
| True = bigNatLogBase# (bigNatFromWord# base) a
@@ -1106,7 +1106,7 @@ bigNatLogBaseWord (W# base) a = W# (bigNatLogBaseWord# base a)
bigNatSizeInBase# :: Word# -> BigNat# -> Word#
bigNatSizeInBase# base a
| isTrue# (base `leWord#` 1##)
- = unexpectedValue_Word# void#
+ = unexpectedValue_Word# (# #)
| bigNatIsZero a
= 0##
@@ -1135,7 +1135,7 @@ powModWord# = bignat_powmod_words
-- | \"@'bigNatPowModWord#' /b/ /e/ /m/@\" computes base @/b/@ raised to
-- exponent @/e/@ modulo @/m/@.
bigNatPowModWord# :: BigNat# -> BigNat# -> Word# -> Word#
-bigNatPowModWord# !_ !_ 0## = raiseDivZero_Word# void#
+bigNatPowModWord# !_ !_ 0## = raiseDivZero_Word# (# #)
bigNatPowModWord# _ _ 1## = 0##
bigNatPowModWord# b e m
| bigNatIsZero e = 1##
@@ -1149,7 +1149,7 @@ bigNatPowMod :: BigNat# -> BigNat# -> BigNat# -> BigNat#
bigNatPowMod !b !e !m
| (# m' | #) <- bigNatToWordMaybe# m
= bigNatFromWord# (bigNatPowModWord# b e m')
- | bigNatIsZero m = raiseDivZero_BigNat void#
+ | bigNatIsZero m = raiseDivZero_BigNat (# #)
| bigNatIsOne m = bigNatFromWord# 0##
| bigNatIsZero e = bigNatFromWord# 1##
| bigNatIsZero b = bigNatFromWord# 0##
@@ -1293,7 +1293,7 @@ bigNatToAddr a addr e = IO \s -> case bigNatToAddr# a addr e s of
--
-- Higher limbs equal to 0 are automatically trimed.
bigNatFromAddrLE# :: Word# -> Addr# -> State# s -> (# State# s, BigNat# #)
-bigNatFromAddrLE# 0## _ s = (# s, bigNatZero# void# #)
+bigNatFromAddrLE# 0## _ s = (# s, bigNatZero# (# #) #)
bigNatFromAddrLE# sz addr s =
let
!nw = sz `uncheckedShiftRL#` WORD_SIZE_BYTES_SHIFT#
@@ -1328,7 +1328,7 @@ bigNatFromAddrLE# sz addr s =
--
-- Null higher limbs are automatically trimed.
bigNatFromAddrBE# :: Word# -> Addr# -> State# s -> (# State# s, BigNat# #)
-bigNatFromAddrBE# 0## _ s = (# s, bigNatZero# void# #)
+bigNatFromAddrBE# 0## _ s = (# s, bigNatZero# (# #) #)
bigNatFromAddrBE# sz addr s =
let
!nw = word2Int# (sz `uncheckedShiftRL#` WORD_SIZE_BYTES_SHIFT#)
@@ -1454,7 +1454,7 @@ bigNatToMutableByteArray# a mba off _ s = bigNatToMutableByteArrayBE# a mba off
--
-- Null higher limbs are automatically trimed.
bigNatFromByteArrayLE# :: Word# -> ByteArray# -> Word# -> State# s -> (# State# s, BigNat# #)
-bigNatFromByteArrayLE# 0## _ _ s = (# s, bigNatZero# void# #)
+bigNatFromByteArrayLE# 0## _ _ s = (# s, bigNatZero# (# #) #)
bigNatFromByteArrayLE# sz ba moff s =
let
!nw = sz `uncheckedShiftRL#` WORD_SIZE_BYTES_SHIFT#
@@ -1489,7 +1489,7 @@ bigNatFromByteArrayLE# sz ba moff s =
--
-- Null higher limbs are automatically trimed.
bigNatFromByteArrayBE# :: Word# -> ByteArray# -> Word# -> State# s -> (# State# s, BigNat# #)
-bigNatFromByteArrayBE# 0## _ _ s = (# s, bigNatZero# void# #)
+bigNatFromByteArrayBE# 0## _ _ s = (# s, bigNatZero# (# #) #)
bigNatFromByteArrayBE# sz ba moff s =
let
!nw = sz `uncheckedShiftRL#` WORD_SIZE_BYTES_SHIFT#
=====================================
libraries/ghc-bignum/src/GHC/Num/BigNat/Check.hs
=====================================
@@ -42,7 +42,7 @@ bignat_compare a b =
gr = Other.bignat_compare a b
nr = Native.bignat_compare a b
in case gr ==# nr of
- 0# -> unexpectedValue_Int# void#
+ 0# -> unexpectedValue_Int# (# #)
_ -> gr
mwaCompare
@@ -380,7 +380,7 @@ bignat_rem_word wa b =
nr = Native.bignat_rem_word wa b
in case gr `eqWord#` nr of
1# -> gr
- _ -> unexpectedValue_Word# void#
+ _ -> unexpectedValue_Word# (# #)
bignat_gcd
:: MutableWordArray# RealWorld
@@ -403,7 +403,7 @@ bignat_gcd_word wa b =
nr = Native.bignat_gcd_word wa b
in case gr `eqWord#` nr of
1# -> gr
- _ -> unexpectedValue_Word# void#
+ _ -> unexpectedValue_Word# (# #)
bignat_gcd_word_word
:: Word#
@@ -415,7 +415,7 @@ bignat_gcd_word_word a b =
nr = Native.bignat_gcd_word_word a b
in case gr `eqWord#` nr of
1# -> gr
- _ -> unexpectedValue_Word# void#
+ _ -> unexpectedValue_Word# (# #)
bignat_encode_double :: WordArray# -> Int# -> Double#
bignat_encode_double a e =
@@ -435,7 +435,7 @@ bignat_powmod_word b e m =
nr = Native.bignat_powmod_word b e m
in case gr `eqWord#` nr of
1# -> gr
- _ -> unexpectedValue_Word# void#
+ _ -> unexpectedValue_Word# (# #)
bignat_powmod
:: MutableWordArray# RealWorld
@@ -460,4 +460,4 @@ bignat_powmod_words b e m =
nr = Native.bignat_powmod_words b e m
in case gr `eqWord#` nr of
1# -> gr
- _ -> unexpectedValue_Word# void#
+ _ -> unexpectedValue_Word# (# #)
=====================================
libraries/ghc-bignum/src/GHC/Num/Integer.hs
=====================================
@@ -120,7 +120,7 @@ integerToBigNatClamp# :: Integer -> BigNat#
integerToBigNatClamp# (IP x) = x
integerToBigNatClamp# (IS x)
| isTrue# (x >=# 0#) = bigNatFromWord# (int2Word# x)
-integerToBigNatClamp# _ = bigNatZero# void#
+integerToBigNatClamp# _ = bigNatZero# (# #)
-- | Create an Integer from an Int#
integerFromInt# :: Int# -> Integer
=====================================
libraries/ghc-bignum/src/GHC/Num/Primitives.hs
=====================================
@@ -247,7 +247,7 @@ wordLog2# w = (WORD_SIZE_IN_BITS## `minusWord#` 1##) `minusWord#` (clz# w)
wordLogBase# :: Word# -> Word# -> Word#
wordLogBase# base a
| isTrue# (base `leWord#` 1##)
- = unexpectedValue_Word# void#
+ = unexpectedValue_Word# (# #)
| 2## <- base
= wordLog2# a
@@ -616,19 +616,19 @@ ioBool (IO io) s = case io s of
-- -- 0## is a dummy value (unreachable code)
--
-unexpectedValue_Int# :: Void# -> Int#
+unexpectedValue_Int# :: (# #) -> Int#
unexpectedValue_Int# _ = case unexpectedValue of
!_ -> 0# -- see Note [ghc-bignum exceptions]
-unexpectedValue_Word# :: Void# -> Word#
+unexpectedValue_Word# :: (# #) -> Word#
unexpectedValue_Word# _ = case unexpectedValue of
!_ -> 0## -- see Note [ghc-bignum exceptions]
-raiseDivZero_Word# :: Void# -> Word#
+raiseDivZero_Word# :: (# #) -> Word#
raiseDivZero_Word# _ = case raiseDivZero of
!_ -> 0## -- see Note [ghc-bignum exceptions]
-raiseUnderflow_Word# :: Void# -> Word#
+raiseUnderflow_Word# :: (# #) -> Word#
raiseUnderflow_Word# _ = case raiseUnderflow of
!_ -> 0## -- see Note [ghc-bignum exceptions]
=====================================
libraries/ghc-prim/GHC/Prim/Exception.hs
=====================================
@@ -28,9 +28,9 @@ default () -- Double and Integer aren't available yet
-- raise exceptions in a normal way because it would create a dependency
-- cycle (base <-> bignum package). See #14664
-foreign import prim "stg_raiseOverflowzh" raiseOverflow# :: State# RealWorld -> (# State# RealWorld, Void# #)
-foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, Void# #)
-foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, Void# #)
+foreign import prim "stg_raiseOverflowzh" raiseOverflow# :: State# RealWorld -> (# State# RealWorld, (# #) #)
+foreign import prim "stg_raiseUnderflowzh" raiseUnderflow# :: State# RealWorld -> (# State# RealWorld, (# #) #)
+foreign import prim "stg_raiseDivZZerozh" raiseDivZero# :: State# RealWorld -> (# State# RealWorld, (# #) #)
-- We give a bottoming demand signature to 'raiseOverflow', 'raiseUnderflow' and
-- 'raiseDivZero' in "GHC.Core.Make". NOINLINE pragmas are necessary because if
=====================================
libraries/ghc-prim/GHC/Prim/Panic.hs
=====================================
@@ -18,8 +18,8 @@ import GHC.Magic
default () -- Double and Integer aren't available yet
-- `stg_panic#` never returns but it can't just return `State# RealWorld` so we
--- indicate that it returns `Void#` too to make the compiler happy.
-foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, Void# #)
+-- indicate that it returns `(# #)` too to make the compiler happy.
+foreign import prim "stg_paniczh" panic# :: Addr# -> State# RealWorld -> (# State# RealWorld, (# #) #)
-- | Display the CString whose address is given as an argument and exit.
panicError :: Addr# -> a
=====================================
libraries/ghc-prim/GHC/Types.hs
=====================================
@@ -38,6 +38,7 @@ module GHC.Types (
-- `type *`, without the parentheses. But that's a true
-- pain to parse, and for little gain.
VecCount(..), VecElem(..),
+ Void#,
-- * Runtime type representation
Module(..), TrName(..), TyCon(..), TypeLitSort(..),
@@ -462,6 +463,9 @@ data VecElem = Int8ElemRep
| DoubleElemRep
-- Enum, Bounded instances in GHC.Enum
+{-# DEPRECATED Void# "Void# is now an alias for the unboxed tuple (# #)." #-}
+type Void# = (# #)
+
{- *********************************************************************
* *
Runtime representation of TyCon
=====================================
testsuite/tests/codeGen/should_compile/T12115.hs
=====================================
@@ -5,5 +5,5 @@ module T12115 where
import GHC.Prim
import GHC.Types
-f :: (# Void#, (# #) #) -> String
+f :: (# (# #), (# #) #) -> String
f = f
=====================================
testsuite/tests/printer/T18052a.stderr
=====================================
@@ -25,7 +25,7 @@ T18052a.$b:||: = \ (@a) (@b) (x :: a) (y :: b) -> (x, y)
-- RHS size: {terms: 13, types: 20, coercions: 0, joins: 0/0}
T18052a.$m:||:
:: forall {rep :: GHC.Types.RuntimeRep} {r :: TYPE rep} {a} {b}.
- (a, b) -> (a -> b -> r) -> (GHC.Prim.Void# -> r) -> r
+ (a, b) -> (a -> b -> r) -> ((# #) -> r) -> r
[GblId, Arity=3, Unf=OtherCon []]
T18052a.$m:||:
= \ (@(rep :: GHC.Types.RuntimeRep))
=====================================
testsuite/tests/simplCore/should_compile/T13143.stderr
=====================================
@@ -6,9 +6,9 @@ Result size of Tidy Core
Rec {
-- RHS size: {terms: 4, types: 4, coercions: 0, joins: 0/0}
T13143.$wf [InlPrag=NOINLINE, Occ=LoopBreaker]
- :: forall {a}. GHC.Prim.Void# -> a
+ :: forall {a}. (# #) -> a
[GblId, Arity=1, Str=<B,A>b, Cpr=b, Unf=OtherCon []]
-T13143.$wf = \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.void#
+T13143.$wf = \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.(##)
end Rec }
-- RHS size: {terms: 4, types: 4, coercions: 0, joins: 0/0}
@@ -20,8 +20,8 @@ f [InlPrag=NOUSERINLINE[final]] :: forall a. Int -> a
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)
- Tmpl= \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.void#}]
-f = \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.void#
+ Tmpl= \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.(##)}]
+f = \ (@a) _ [Occ=Dead] -> T13143.$wf @a GHC.Prim.(##)
-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
T13143.$trModule4 :: GHC.Prim.Addr#
@@ -62,7 +62,7 @@ T13143.$trModule
-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
lvl :: Int
[GblId, Str=b, Cpr=b]
-lvl = T13143.$wf @Int GHC.Prim.void#
+lvl = T13143.$wf @Int GHC.Prim.(##)
Rec {
-- RHS size: {terms: 28, types: 7, coercions: 0, joins: 0/0}
=====================================
testsuite/tests/unboxedsums/ffi1.hs
=====================================
@@ -2,7 +2,7 @@
module Lib where
-import GHC.Prim
+import GHC.Exts
-- Can't unboxed tuples and sums to FFI, we should fail appropriately.
=====================================
utils/genprimopcode/Main.hs
=====================================
@@ -923,8 +923,6 @@ ppType (TyApp (TyCon "IOPort#") [x,y]) = "mkIOPortPrimTy " ++ ppType x
++ " " ++ ppType y
ppType (TyApp (TyCon "TVar#") [x,y]) = "mkTVarPrimTy " ++ ppType x
++ " " ++ ppType y
-ppType (TyApp (TyCon "Void#") []) = "voidPrimTy"
-
ppType (TyApp (VecTyCon _ pptc) []) = pptc
ppType (TyUTup ts) = "(mkTupleTy Unboxed "
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/cfa89149b55837f822ba619b797781813fdcdabc
--
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/cfa89149b55837f822ba619b797781813fdcdabc
You're receiving this email because of your account on gitlab.haskell.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-commits/attachments/20200722/962f079f/attachment-0001.html>
More information about the ghc-commits
mailing list