- ghc-commits - Haskell.org

[Git][ghc/ghc][wip/int-index/drop-tylit] 12 commits: Remove `GHC.Desugar` from `base`
by Vladislav Zavialov (＠int-index) 03 Feb '26

03 Feb '26

Vladislav Zavialov pushed to branch wip/int-index/drop-tylit at Glasgow Haskell Compiler / GHC Commits: 607b287b by Wolfgang Jeltsch at 2026-01-28T15:41:53+02:00 Remove `GHC.Desugar` from `base` `GHC.Desugar` was deprecated and should have been removed in GHC 9.14. However, the removal was forgotten, although there was a code block that was intended to trigger a compilation error when the GHC version in use was 9.14 or later. This code sadly didn’t work, because the `__GLASGOW_HASKELL__` macro was misspelled as `__GLASGOW_HASKELL`. - - - - - e8f5a45d by sterni at 2026-01-29T04:19:18-05:00 users_guide: fix runtime error during build with Sphinx 9.1.0 Appears that pathto is stricter about what it accepts now. Tested Sphinx 8.2.3 and 9.1.0 on the ghc-9.10 branch. Resolves #26810. Co-authored-by: Martin Weinelt <hexa(a)darmstadt.ccc.de> - - - - - ce2d62fb by Jessica Clarke at 2026-01-29T19:48:51-05:00 PPC NCG: Use libcall for 64-bit cmpxchg on 32-bit PowerPC There is no native instruction for this, and even if there were a register pair version we could use, the implementation here is assuming the values fit in a single register, and we end up only using / defining the low halves of the registers. Fixes: b4d39adbb5 ("PrimOps: Add CAS op for all int sizes") Fixes: #23969 - - - - - 43d97761 by Michael Karcher at 2026-01-29T19:49:43-05:00 NCG for PPC: add pattern for CmmRegOff to iselExpr64 Closes #26828 - - - - - aeeb4a20 by Matthew Pickering at 2026-01-30T11:42:47-05:00 determinism: Use deterministic map for Strings in TyLitMap When generating typeable evidence the types we need evidence for all cached in a TypeMap, the order terms are retrieved from a type map determines the order the bindings appear in the program. A TypeMap is quite diligent to use deterministic maps, apart from in the TyLitMap, which uses a UniqFM for storing strings, whose ordering depends on the Unique of the FastString. This can cause non-deterministic .hi and .o files. An unexpected side-effect is the error message but RecordDotSyntaxFail8 changing. I looked into this with Sam and this change caused the constraints to be solved in a different order which results in a slightly different error message. I have accepted the new test, since the output before was non-deterministic and the new output is consistent with the other messages in that file. Fixes #26846 - - - - - 9e4d70c2 by Andrew Lelechenko at 2026-01-30T11:43:29-05:00 Upgrade text submodule to 2.1.4 - - - - - 631fa5ae by Recursion Ninja at 2026-01-31T22:30:11+00:00 Decouple `L.S.H.Decls` from importing `GHC.Types.Basic` Data-types within `GHC.Types.Basic` which describe components of the AST are migrated to `Language.Haskell.Syntax.Basic`. Related function definitions are also moved. Types moved to L.H.S. because they are part of the AST: * TopLevelFlag * RuleName Types moved from L.H.S. to GHC.Hs. because they are not needed in the AST: * TyConFlavour * TypeOrData * NewOrData Migrated instances: * `Outputable` instances moved to in `GHC.Utils.Outputable` * `Binary` instance of `Boxity` moved to to `GHC.Utils.Binary` * Other `Binary` instances are orphans to be migrated later. The `OverlapMode` data-type is given a TTG extension point. The `OverlapFlag` data-type, which depends on `OverlapMode`, is updated to support `OverlapMode` with a GHC "pass" type paramerter. In order to avoid module import cycles, `OverlapMode` and `OverlapFlag` are migrated to new modules (no way around this). * Migrated `OverlapMode` to new module `Language.Haskell.Syntax.Overlap` * Migrated `OverlapFlag` to new module `GHC.Hs.Decls.Overlap` - - - - - 9769cc03 by Simon Hengel at 2026-02-01T04:21:03-05:00 Update the documentation for MultiWayIf (fixes #25376) (so that it matches the implementation) - - - - - 5fc9442a by Peter Trommler at 2026-02-01T04:21:44-05:00 hadrian: Fix dependency generation for assembler Assembler files allow # for comments unless in column 1. A modern cpp for C treats those a preprocessor directives. We tell gcc that a .S file is assembler with cpp and not C. Fixes #26819 - - - - - 269c4087 by Simon Peyton Jones at 2026-02-01T19:38:10-05:00 Include current phase in the range for rule/unfoldings This MR fixes a bad loop in the compiler: #26826. The fix is to add (WAR2) to Note [What is active in the RHS of a RULE or unfolding?] in GHC.Core.Opt.Simplify.Utils - - - - - ddf1434f by Vladislav Zavialov at 2026-02-01T19:38:52-05:00 Refactor: merge HsMultilineString into HsString (#26860) Before this patch, HsLit defined two separate constructors to represent single-line and multi-line strings: data HsLit x ... | HsString (XHsString x) FastString | HsMultilineString (XHsMultilineString x) FastString I found this to be an unnecessary complication and an obstacle to unifying HsLit with HsTyLit. Now we use HsString for both kinds of literals. One user-facing change here is `ppr (HsString st s)` behaving differently for single-line strings containing newlines: x = "first line \ \asdf\n\ \second line" Previously, the literal was fed to `ftext` with its newlines, producing an ill-formed SDoc. This issue is now addressed by using `split` for both single-line and multi-line strings: vcat $ map text $ split '\n' (unpackFS src) See the parser/should_fail/T26860ppr test. In addition (and unrelatedly to the main payload of this patch), drop the unused pmPprHsLit helper. - - - - - 4a1a1ba6 by Vladislav Zavialov at 2026-02-03T12:39:29+03:00 WIP: Drop HsTyLit in favor of HsLit - - - - - 95 changed files: - compiler/GHC/CmmToAsm/PPC/CodeGen.hs - compiler/GHC/Core/InstEnv.hs - compiler/GHC/Core/Map/Type.hs - compiler/GHC/Core/Opt/OccurAnal.hs - compiler/GHC/Core/Opt/Simplify/Env.hs - compiler/GHC/Core/Opt/Simplify/Utils.hs - compiler/GHC/Core/Opt/WorkWrap.hs - compiler/GHC/Hs/Decls.hs - + compiler/GHC/Hs/Decls/Overlap.hs - compiler/GHC/Hs/Instances.hs - compiler/GHC/Hs/Lit.hs - compiler/GHC/Hs/Syn/Type.hs - compiler/GHC/Hs/Type.hs - compiler/GHC/Hs/Utils.hs - compiler/GHC/HsToCore/Errors/Ppr.hs - compiler/GHC/HsToCore/Errors/Types.hs - compiler/GHC/HsToCore/Match/Literal.hs - compiler/GHC/HsToCore/Quote.hs - compiler/GHC/Iface/Ext/Ast.hs - compiler/GHC/Iface/Syntax.hs - compiler/GHC/Parser.y - compiler/GHC/Parser/PostProcess.hs - compiler/GHC/Parser/String.hs - compiler/GHC/Rename/Env.hs - compiler/GHC/Rename/Expr.hs - compiler/GHC/Rename/HsType.hs - compiler/GHC/Rename/Module.hs - compiler/GHC/Rename/Names.hs - compiler/GHC/Rename/Pat.hs - compiler/GHC/Rename/Splice.hs - compiler/GHC/Rename/Utils.hs - compiler/GHC/Tc/Deriv.hs - compiler/GHC/Tc/Deriv/Utils.hs - compiler/GHC/Tc/Errors/Ppr.hs - compiler/GHC/Tc/Errors/Types.hs - compiler/GHC/Tc/Gen/App.hs - compiler/GHC/Tc/Gen/Head.hs - compiler/GHC/Tc/Gen/HsType.hs - compiler/GHC/Tc/Gen/Pat.hs - compiler/GHC/Tc/Utils/Env.hs - compiler/GHC/Tc/Utils/Instantiate.hs - compiler/GHC/Tc/Utils/Monad.hs - compiler/GHC/ThToHs.hs - compiler/GHC/Types/Basic.hs - compiler/GHC/Types/Error/Codes.hs - compiler/GHC/Types/InlinePragma.hs - compiler/GHC/Types/Name.hs - compiler/GHC/Types/SourceText.hs - compiler/GHC/Unit/Types.hs - compiler/GHC/Utils/Binary.hs - compiler/GHC/Utils/Outputable.hs - compiler/Language/Haskell/Syntax/Basic.hs - compiler/Language/Haskell/Syntax/Decls.hs - + compiler/Language/Haskell/Syntax/Decls/Overlap.hs - compiler/Language/Haskell/Syntax/Expr.hs - compiler/Language/Haskell/Syntax/Extension.hs - compiler/Language/Haskell/Syntax/Lit.hs - compiler/Language/Haskell/Syntax/Type.hs - compiler/ghc.cabal.in - docs/users_guide/exts/multiway_if.rst - docs/users_guide/rtd-theme/layout.html - hadrian/src/Builder.hs - hadrian/src/Rules/Compile.hs - hadrian/src/Settings/Builders/Cc.hs - hadrian/src/Settings/Packages.hs - libraries/base/base.cabal.in - − libraries/base/src/GHC/Desugar.hs - libraries/text - testsuite/tests/count-deps/CountDepsAst.stdout - testsuite/tests/count-deps/CountDepsParser.stdout - + testsuite/tests/ghc-api/TypeMapStringLiteral.hs - testsuite/tests/ghc-api/all.T - testsuite/tests/ghc-api/annotations-literals/parsed.hs - testsuite/tests/interface-stability/base-exports.stdout - testsuite/tests/interface-stability/base-exports.stdout-javascript-unknown-ghcjs - testsuite/tests/interface-stability/base-exports.stdout-mingw32 - testsuite/tests/interface-stability/base-exports.stdout-ws-32 - testsuite/tests/parser/should_fail/RecordDotSyntaxFail8.stderr - + testsuite/tests/parser/should_fail/T26860ppr.hs - + testsuite/tests/parser/should_fail/T26860ppr.stderr - testsuite/tests/parser/should_fail/all.T - + testsuite/tests/simplCore/should_compile/T26826.hs - testsuite/tests/simplCore/should_compile/all.T - + testsuite/tests/typecheck/should_fail/T26861.hs - + testsuite/tests/typecheck/should_fail/T26861.stderr - + testsuite/tests/typecheck/should_fail/T26862.hs - + testsuite/tests/typecheck/should_fail/T26862.stderr - testsuite/tests/typecheck/should_fail/all.T - utils/check-exact/ExactPrint.hs - utils/haddock/haddock-api/src/Haddock/Backends/Hoogle.hs - utils/haddock/haddock-api/src/Haddock/Backends/LaTeX.hs - utils/haddock/haddock-api/src/Haddock/Backends/Xhtml/Decl.hs - utils/haddock/haddock-api/src/Haddock/Convert.hs - utils/haddock/haddock-api/src/Haddock/Interface/Rename.hs - utils/haddock/haddock-api/src/Haddock/Types.hs The diff was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/85d786928812a6fb5b9a17f65b1250… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/85d786928812a6fb5b9a17f65b1250… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc] Pushed new branch wip/on-exception-annotate
by Matthew Pickering (＠mpickering) 03 Feb '26

03 Feb '26

Matthew Pickering pushed new branch wip/on-exception-annotate at Glasgow Haskell Compiler / GHC -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/tree/wip/on-exception-annotate You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/andreask/ticked_joins] WIP: debugging
by sheaf (＠sheaf) 03 Feb '26

03 Feb '26

sheaf pushed to branch wip/andreask/ticked_joins at Glasgow Haskell Compiler / GHC Commits: f6027208 by sheaf at 2026-02-03T10:12:03+01:00 WIP: debugging - - - - - 4 changed files: - compiler/GHC/Core/Opt/Simplify/Iteration.hs - compiler/GHC/Core/SimpleOpt.hs - compiler/GHC/Types/Id.hs - testsuite/tests/simplCore/should_compile/QuasiJoinPoints.hs Changes: ===================================== compiler/GHC/Core/Opt/Simplify/Iteration.hs ===================================== @@ -1914,7 +1914,7 @@ simplNonRecE :: HasDebugCallStack -- Otherwise it may or may not satisfy it. simplNonRecE env from_what bndr (rhs, rhs_se) body cont - | assert (isId bndr && not (isJoinId bndr) ) $ + | assert (isId bndr && not (isJoinId bndr)) $ is_strict_bind = -- Evaluate RHS strictly simplExprF (rhs_se `setInScopeFromE` env) rhs ===================================== compiler/GHC/Core/SimpleOpt.hs ===================================== @@ -1080,23 +1080,36 @@ joinPointBinding_maybe bndr rhs -- need to demote it to a quasi join-point. -- See Note [Quasi join points] in GHC.Core.Opt.Simplify.Iteration. | Just orig_cat <- joinId_maybe bndr - , AlwaysTailCalled - { tailCallArity = _new_arity - , tailCallJoinPointType = new_cat } - <- tailCallInfo (idOccInfo bndr) - = assertPpr (idJoinArity bndr == _new_arity) - ( vcat [ text "joinPointBinding_maybe: incompatible join arities " - , text "bndr:" <+> ppr bndr - , text "rhs:" <+> ppr rhs - , text "prev arity:" <+> ppr (idJoinArity bndr) - , text " new arity:" <+> ppr _new_arity - , text "orig_cat:" <+> ppr orig_cat - , text " new_cat:" <+> ppr new_cat - ] - ) $ Just $ - if orig_cat == new_cat - then (bndr, rhs) - else (asJoinId bndr new_cat (idJoinArity bndr), rhs) + = case tailCallInfo (idOccInfo bndr) of + NoTailCallInfo -> + pprTrace "joinPointBinding_maybe: lost join?" + (vcat + [ text "bndr:" <+> ppr bndr + , text "rhs:" <+> ppr rhs + , text "arity:" <+> ppr (idJoinArity bndr) + , text "cat:" <+> ppr orig_cat + , text "occ_info:" <+> ppr (idOccInfo bndr) + ]) $ + -- SLD TODO: I don't understand how this can happen, but apparently + -- it can. For now I'm preserving the join, but further investigation + -- is needed. + Just (bndr, rhs) + AlwaysTailCalled + { tailCallArity = _new_arity + , tailCallJoinPointType = new_cat } -> + assertPpr (idJoinArity bndr == _new_arity) + ( vcat [ text "joinPointBinding_maybe: incompatible join arities " + , text "bndr:" <+> ppr bndr + , text "rhs:" <+> ppr rhs + , text "prev arity:" <+> ppr (idJoinArity bndr) + , text " new arity:" <+> ppr _new_arity + , text "orig_cat:" <+> ppr orig_cat + , text " new_cat:" <+> ppr new_cat + ] + ) $ Just $ + if orig_cat == new_cat + then (bndr, rhs) + else (asJoinId bndr new_cat (idJoinArity bndr), rhs) | AlwaysTailCalled { tailCallArity = join_arity ===================================== compiler/GHC/Types/Id.hs ===================================== @@ -692,7 +692,7 @@ idJoinArity id = JoinPoint { joinPointArity = ar } -> ar NotJoinPoint -> pprPanic "idJoinArity" (ppr id) -asJoinId :: Id -> JoinPointCategory -> JoinArity -> JoinId +asJoinId :: HasDebugCallStack => Id -> JoinPointCategory -> JoinArity -> JoinId asJoinId id cat arity = warnPprTrace (not (isLocalId id)) "global id being marked as join var" (ppr id) $ ===================================== testsuite/tests/simplCore/should_compile/QuasiJoinPoints.hs ===================================== @@ -133,3 +133,50 @@ testQuasiTransitivity b n = True -> {-# SCC "ticked" #-} j3 10 False -> j3 20 ) + +-------------------------------------------------------------------------------- +-- Extracted from a GHC bootstrapping bug + +data AB = A | B + +data Int2 = MkInt2 + +expt :: Int2 -> Int2 +expt _ = MkInt2 +{-# NOINLINE expt #-} + +add :: Int2 -> Int2 -> Int2 +add _ _ = MkInt2 +{-# NOINLINE add #-} + +big :: Int2 -> AB +big _ = A +{-# NOINLINE big #-} + +baz :: Int2 +baz = MkInt2 +{-# NOINLINE baz #-} + +no :: a +no = no +{-# NOINLINE no #-} + +mul :: Int2 -> Int2 -> Int2 +mul !_ !_ = no +{-# INLINE mul #-} + +data T2 a b = MkT2 a b + +floatToDigits2 :: T2 Int2 Int2 -> T2 Int2 Int2 +floatToDigits2 ( MkT2 f0 e0 ) = + let + MkT2 f e = + let n = e0 + in + case big n of + A -> MkT2 f0 ( add e0 n ) + B -> MkT2 f0 e0 + r = let be = expt e in mul f be + + in + MkT2 r baz View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/f6027208357b11e92d2c30918da3ed9… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/f6027208357b11e92d2c30918da3ed9… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/marge_bot_batch_merge_job] Refactor: make function patterns exhaustive
by Marge Bot (＠marge-bot) 03 Feb '26

03 Feb '26

Marge Bot pushed to branch wip/marge_bot_batch_merge_job at Glasgow Haskell Compiler / GHC Commits: 02183ced by Brandon Chinn at 2026-02-03T03:44:09-05:00 Refactor: make function patterns exhaustive Also added missing (==) logic for: * HsMultilineString * HsInt{8,16,32} * HsWord{8,16,32} - - - - - 2 changed files: - compiler/GHC/ThToHs.hs - compiler/Language/Haskell/Syntax/Lit.hs Changes: ===================================== compiler/GHC/ThToHs.hs ===================================== @@ -1462,10 +1462,11 @@ cvtLit (BytesPrimL (Bytes fptr off sz)) = do BS.packCStringLen (ptr `plusPtr` fromIntegral off, fromIntegral sz) force bs return $ HsStringPrim NoSourceText bs -cvtLit _ = panic "Convert.cvtLit: Unexpected literal" - -- cvtLit should not be called on IntegerL, RationalL - -- That precondition is established right here in - -- "GHC.ThToHs", hence panic +-- cvtLit should not be called on IntegerL, RationalL +-- That precondition is established right here in +-- "GHC.ThToHs", hence panic +cvtLit (IntegerL _) = panic "Convert.cvtLit: Unexpected literal" +cvtLit (RationalL _) = panic "Convert.cvtLit: Unexpected literal" quotedSourceText :: String -> SourceText quotedSourceText s = SourceText $ fsLit $ "\"" ++ s ++ "\"" ===================================== compiler/Language/Haskell/Syntax/Lit.hs ===================================== @@ -79,19 +79,42 @@ data HsLit x | XLit !(XXLit x) instance (Eq (XXLit x)) => Eq (HsLit x) where - (HsChar _ x1) == (HsChar _ x2) = x1==x2 - (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2 - (HsString _ x1) == (HsString _ x2) = x1==x2 - (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2 - (HsInt _ x1) == (HsInt _ x2) = x1==x2 - (HsIntPrim _ x1) == (HsIntPrim _ x2) = x1==x2 - (HsWordPrim _ x1) == (HsWordPrim _ x2) = x1==x2 - (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2 - (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2 - (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2 - (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2 - (XLit x1) == (XLit x2) = x1==x2 - _ == _ = False + HsChar _ x1 == HsChar _ x2 = x1 == x2 + HsChar{} == _ = False + HsCharPrim _ x1 == HsCharPrim _ x2 = x1 == x2 + HsCharPrim{} == _ = False + HsString _ x1 == HsString _ x2 = x1 == x2 + HsString{} == _ = False + HsStringPrim _ x1 == HsStringPrim _ x2 = x1 == x2 + HsStringPrim{} == _ = False + HsInt _ x1 == HsInt _ x2 = x1 == x2 + HsInt{} == _ = False + HsIntPrim _ x1 == HsIntPrim _ x2 = x1 == x2 + HsIntPrim{} == _ = False + HsWordPrim _ x1 == HsWordPrim _ x2 = x1 == x2 + HsWordPrim{} == _ = False + HsInt8Prim _ x1 == HsInt8Prim _ x2 = x1 == x2 + HsInt8Prim{} == _ = False + HsInt16Prim _ x1 == HsInt16Prim _ x2 = x1 == x2 + HsInt16Prim{} == _ = False + HsInt32Prim _ x1 == HsInt32Prim _ x2 = x1 == x2 + HsInt32Prim{} == _ = False + HsInt64Prim _ x1 == HsInt64Prim _ x2 = x1 == x2 + HsInt64Prim{} == _ = False + HsWord8Prim _ x1 == HsWord8Prim _ x2 = x1 == x2 + HsWord8Prim{} == _ = False + HsWord16Prim _ x1 == HsWord16Prim _ x2 = x1 == x2 + HsWord16Prim{} == _ = False + HsWord32Prim _ x1 == HsWord32Prim _ x2 = x1 == x2 + HsWord32Prim{} == _ = False + HsWord64Prim _ x1 == HsWord64Prim _ x2 = x1 == x2 + HsWord64Prim{} == _ = False + HsFloatPrim _ x1 == HsFloatPrim _ x2 = x1 == x2 + HsFloatPrim{} == _ = False + HsDoublePrim _ x1 == HsDoublePrim _ x2 = x1 == x2 + HsDoublePrim{} == _ = False + XLit x1 == XLit x2 = x1 == x2 + XLit{} == _ = False -- | Haskell Overloaded Literal data HsOverLit p @@ -112,18 +135,23 @@ data OverLitVal deriving Data instance Eq OverLitVal where - (HsIntegral i1) == (HsIntegral i2) = i1 == i2 - (HsFractional f1) == (HsFractional f2) = f1 == f2 - (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2 - _ == _ = False + HsIntegral i1 == HsIntegral i2 = i1 == i2 + HsIntegral{} == _ = False + HsFractional f1 == HsFractional f2 = f1 == f2 + HsFractional{} == _ = False + HsIsString _ s1 == HsIsString _ s2 = s1 == s2 + HsIsString{} == _ = False instance Ord OverLitVal where - compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2 - compare (HsIntegral _) (HsFractional _) = LT - compare (HsIntegral _) (HsIsString _ _) = LT - compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2 - compare (HsFractional _) (HsIntegral _) = GT - compare (HsFractional _) (HsIsString _ _) = LT - compare (HsIsString _ s1) (HsIsString _ s2) = s1 `lexicalCompareFS` s2 - compare (HsIsString _ _) (HsIntegral _) = GT - compare (HsIsString _ _) (HsFractional _) = GT + -- HsIntegral + HsIntegral i1 `compare` HsIntegral i2 = i1 `compare` i2 + HsIntegral{} `compare` HsFractional{} = LT + HsIntegral{} `compare` HsIsString{} = LT + -- HsFractional + HsFractional{} `compare` HsIntegral{} = GT + HsFractional f1 `compare` HsFractional f2 = f1 `compare` f2 + HsFractional{} `compare` HsIsString{} = LT + -- HsIsString + HsIsString{} `compare` HsIntegral{} = GT + HsIsString{} `compare` HsFractional{} = GT + HsIsString _ s1 `compare` HsIsString _ s2 = s1 `lexicalCompareFS` s2 View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/02183cedc794c24fee2265e510cfe99… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/02183cedc794c24fee2265e510cfe99… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc] Pushed new branch wip/ani/kill-SrcCodeOrigin
by Apoorv Ingle (＠ani) 03 Feb '26

03 Feb '26

Apoorv Ingle pushed new branch wip/ani/kill-SrcCodeOrigin at Glasgow Haskell Compiler / GHC -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/tree/wip/ani/kill-SrcCodeOrigin You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/bchinn-cvtlit-exhaustive] 6 commits: Decouple `L.S.H.Decls` from importing `GHC.Types.Basic`
by Brandon Chinn (＠brandonchinn178) 03 Feb '26

03 Feb '26

Brandon Chinn pushed to branch wip/bchinn-cvtlit-exhaustive at Glasgow Haskell Compiler / GHC Commits: 631fa5ae by Recursion Ninja at 2026-01-31T22:30:11+00:00 Decouple `L.S.H.Decls` from importing `GHC.Types.Basic` Data-types within `GHC.Types.Basic` which describe components of the AST are migrated to `Language.Haskell.Syntax.Basic`. Related function definitions are also moved. Types moved to L.H.S. because they are part of the AST: * TopLevelFlag * RuleName Types moved from L.H.S. to GHC.Hs. because they are not needed in the AST: * TyConFlavour * TypeOrData * NewOrData Migrated instances: * `Outputable` instances moved to in `GHC.Utils.Outputable` * `Binary` instance of `Boxity` moved to to `GHC.Utils.Binary` * Other `Binary` instances are orphans to be migrated later. The `OverlapMode` data-type is given a TTG extension point. The `OverlapFlag` data-type, which depends on `OverlapMode`, is updated to support `OverlapMode` with a GHC "pass" type paramerter. In order to avoid module import cycles, `OverlapMode` and `OverlapFlag` are migrated to new modules (no way around this). * Migrated `OverlapMode` to new module `Language.Haskell.Syntax.Overlap` * Migrated `OverlapFlag` to new module `GHC.Hs.Decls.Overlap` - - - - - 9769cc03 by Simon Hengel at 2026-02-01T04:21:03-05:00 Update the documentation for MultiWayIf (fixes #25376) (so that it matches the implementation) - - - - - 5fc9442a by Peter Trommler at 2026-02-01T04:21:44-05:00 hadrian: Fix dependency generation for assembler Assembler files allow # for comments unless in column 1. A modern cpp for C treats those a preprocessor directives. We tell gcc that a .S file is assembler with cpp and not C. Fixes #26819 - - - - - 269c4087 by Simon Peyton Jones at 2026-02-01T19:38:10-05:00 Include current phase in the range for rule/unfoldings This MR fixes a bad loop in the compiler: #26826. The fix is to add (WAR2) to Note [What is active in the RHS of a RULE or unfolding?] in GHC.Core.Opt.Simplify.Utils - - - - - ddf1434f by Vladislav Zavialov at 2026-02-01T19:38:52-05:00 Refactor: merge HsMultilineString into HsString (#26860) Before this patch, HsLit defined two separate constructors to represent single-line and multi-line strings: data HsLit x ... | HsString (XHsString x) FastString | HsMultilineString (XHsMultilineString x) FastString I found this to be an unnecessary complication and an obstacle to unifying HsLit with HsTyLit. Now we use HsString for both kinds of literals. One user-facing change here is `ppr (HsString st s)` behaving differently for single-line strings containing newlines: x = "first line \ \asdf\n\ \second line" Previously, the literal was fed to `ftext` with its newlines, producing an ill-formed SDoc. This issue is now addressed by using `split` for both single-line and multi-line strings: vcat $ map text $ split '\n' (unpackFS src) See the parser/should_fail/T26860ppr test. In addition (and unrelatedly to the main payload of this patch), drop the unused pmPprHsLit helper. - - - - - 8ce9251e by Brandon Chinn at 2026-02-02T20:48:36-08:00 Refactor: make function patterns exhaustive Also added missing (==) logic for: * HsMultilineString * HsInt{8,16,32} * HsWord{8,16,32} - - - - - 61 changed files: - compiler/GHC/Core/InstEnv.hs - compiler/GHC/Core/Opt/OccurAnal.hs - compiler/GHC/Core/Opt/Simplify/Env.hs - compiler/GHC/Core/Opt/Simplify/Utils.hs - compiler/GHC/Core/Opt/WorkWrap.hs - compiler/GHC/Hs/Decls.hs - + compiler/GHC/Hs/Decls/Overlap.hs - compiler/GHC/Hs/Instances.hs - compiler/GHC/Hs/Lit.hs - compiler/GHC/Hs/Syn/Type.hs - compiler/GHC/Hs/Utils.hs - compiler/GHC/HsToCore/Errors/Types.hs - compiler/GHC/HsToCore/Match/Literal.hs - compiler/GHC/HsToCore/Quote.hs - compiler/GHC/Iface/Ext/Ast.hs - compiler/GHC/Iface/Syntax.hs - compiler/GHC/Parser.y - compiler/GHC/Parser/String.hs - compiler/GHC/Rename/Env.hs - compiler/GHC/Rename/Expr.hs - compiler/GHC/Rename/Module.hs - compiler/GHC/Rename/Names.hs - compiler/GHC/Rename/Splice.hs - compiler/GHC/Tc/Deriv.hs - compiler/GHC/Tc/Deriv/Utils.hs - compiler/GHC/Tc/Errors/Ppr.hs - compiler/GHC/Tc/Gen/Head.hs - compiler/GHC/Tc/Gen/HsType.hs - compiler/GHC/Tc/Utils/Env.hs - compiler/GHC/Tc/Utils/Instantiate.hs - compiler/GHC/Tc/Utils/Monad.hs - compiler/GHC/ThToHs.hs - compiler/GHC/Types/Basic.hs - compiler/GHC/Types/InlinePragma.hs - compiler/GHC/Types/Name.hs - compiler/GHC/Unit/Types.hs - compiler/GHC/Utils/Binary.hs - compiler/GHC/Utils/Outputable.hs - compiler/Language/Haskell/Syntax/Basic.hs - compiler/Language/Haskell/Syntax/Decls.hs - + compiler/Language/Haskell/Syntax/Decls/Overlap.hs - compiler/Language/Haskell/Syntax/Extension.hs - compiler/Language/Haskell/Syntax/Lit.hs - compiler/ghc.cabal.in - docs/users_guide/exts/multiway_if.rst - hadrian/src/Builder.hs - hadrian/src/Rules/Compile.hs - hadrian/src/Settings/Builders/Cc.hs - hadrian/src/Settings/Packages.hs - testsuite/tests/count-deps/CountDepsAst.stdout - testsuite/tests/count-deps/CountDepsParser.stdout - + testsuite/tests/parser/should_fail/T26860ppr.hs - + testsuite/tests/parser/should_fail/T26860ppr.stderr - testsuite/tests/parser/should_fail/all.T - + testsuite/tests/simplCore/should_compile/T26826.hs - testsuite/tests/simplCore/should_compile/all.T - utils/check-exact/ExactPrint.hs - utils/haddock/haddock-api/src/Haddock/Backends/Hoogle.hs - utils/haddock/haddock-api/src/Haddock/Convert.hs - utils/haddock/haddock-api/src/Haddock/Interface/Rename.hs - utils/haddock/haddock-api/src/Haddock/Types.hs The diff was not included because it is too large. View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/fa20b0182bcdff042a19b72add11ce… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/fa20b0182bcdff042a19b72add11ce… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/marge_bot_batch_merge_job] Refactor: make function patterns exhaustive
by Marge Bot (＠marge-bot) 03 Feb '26

03 Feb '26

Marge Bot pushed to branch wip/marge_bot_batch_merge_job at Glasgow Haskell Compiler / GHC Commits: 606cf582 by Brandon Chinn at 2026-02-02T23:09:24-05:00 Refactor: make function patterns exhaustive Also added missing (==) logic for: * HsMultilineString * HsInt{8,16,32} * HsWord{8,16,32} - - - - - 2 changed files: - compiler/GHC/ThToHs.hs - compiler/Language/Haskell/Syntax/Lit.hs Changes: ===================================== compiler/GHC/ThToHs.hs ===================================== @@ -1462,10 +1462,11 @@ cvtLit (BytesPrimL (Bytes fptr off sz)) = do BS.packCStringLen (ptr `plusPtr` fromIntegral off, fromIntegral sz) force bs return $ HsStringPrim NoSourceText bs -cvtLit _ = panic "Convert.cvtLit: Unexpected literal" - -- cvtLit should not be called on IntegerL, RationalL - -- That precondition is established right here in - -- "GHC.ThToHs", hence panic +-- cvtLit should not be called on IntegerL, RationalL +-- That precondition is established right here in +-- "GHC.ThToHs", hence panic +cvtLit (IntegerL _) = panic "Convert.cvtLit: Unexpected literal" +cvtLit (RationalL _) = panic "Convert.cvtLit: Unexpected literal" quotedSourceText :: String -> SourceText quotedSourceText s = SourceText $ fsLit $ "\"" ++ s ++ "\"" ===================================== compiler/Language/Haskell/Syntax/Lit.hs ===================================== @@ -79,19 +79,44 @@ data HsLit x | XLit !(XXLit x) instance (Eq (XXLit x)) => Eq (HsLit x) where - (HsChar _ x1) == (HsChar _ x2) = x1==x2 - (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2 - (HsString _ x1) == (HsString _ x2) = x1==x2 - (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2 - (HsInt _ x1) == (HsInt _ x2) = x1==x2 - (HsIntPrim _ x1) == (HsIntPrim _ x2) = x1==x2 - (HsWordPrim _ x1) == (HsWordPrim _ x2) = x1==x2 - (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2 - (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2 - (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2 - (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2 - (XLit x1) == (XLit x2) = x1==x2 - _ == _ = False + HsChar _ x1 == HsChar _ x2 = x1 == x2 + HsChar{} == _ = False + HsCharPrim _ x1 == HsCharPrim _ x2 = x1 == x2 + HsCharPrim{} == _ = False + HsString _ x1 == HsString _ x2 = x1 == x2 + HsString{} == _ = False + HsMultilineString _ x1 == HsMultilineString _ x2 = x1 == x2 + HsMultilineString{} == _ = False + HsStringPrim _ x1 == HsStringPrim _ x2 = x1 == x2 + HsStringPrim{} == _ = False + HsInt _ x1 == HsInt _ x2 = x1 == x2 + HsInt{} == _ = False + HsIntPrim _ x1 == HsIntPrim _ x2 = x1 == x2 + HsIntPrim{} == _ = False + HsWordPrim _ x1 == HsWordPrim _ x2 = x1 == x2 + HsWordPrim{} == _ = False + HsInt8Prim _ x1 == HsInt8Prim _ x2 = x1 == x2 + HsInt8Prim{} == _ = False + HsInt16Prim _ x1 == HsInt16Prim _ x2 = x1 == x2 + HsInt16Prim{} == _ = False + HsInt32Prim _ x1 == HsInt32Prim _ x2 = x1 == x2 + HsInt32Prim{} == _ = False + HsInt64Prim _ x1 == HsInt64Prim _ x2 = x1 == x2 + HsInt64Prim{} == _ = False + HsWord8Prim _ x1 == HsWord8Prim _ x2 = x1 == x2 + HsWord8Prim{} == _ = False + HsWord16Prim _ x1 == HsWord16Prim _ x2 = x1 == x2 + HsWord16Prim{} == _ = False + HsWord32Prim _ x1 == HsWord32Prim _ x2 = x1 == x2 + HsWord32Prim{} == _ = False + HsWord64Prim _ x1 == HsWord64Prim _ x2 = x1 == x2 + HsWord64Prim{} == _ = False + HsFloatPrim _ x1 == HsFloatPrim _ x2 = x1 == x2 + HsFloatPrim{} == _ = False + HsDoublePrim _ x1 == HsDoublePrim _ x2 = x1 == x2 + HsDoublePrim{} == _ = False + XLit x1 == XLit x2 = x1 == x2 + XLit{} == _ = False -- | Haskell Overloaded Literal data HsOverLit p @@ -112,18 +137,23 @@ data OverLitVal deriving Data instance Eq OverLitVal where - (HsIntegral i1) == (HsIntegral i2) = i1 == i2 - (HsFractional f1) == (HsFractional f2) = f1 == f2 - (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2 - _ == _ = False + HsIntegral i1 == HsIntegral i2 = i1 == i2 + HsIntegral{} == _ = False + HsFractional f1 == HsFractional f2 = f1 == f2 + HsFractional{} == _ = False + HsIsString _ s1 == HsIsString _ s2 = s1 == s2 + HsIsString{} == _ = False instance Ord OverLitVal where - compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2 - compare (HsIntegral _) (HsFractional _) = LT - compare (HsIntegral _) (HsIsString _ _) = LT - compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2 - compare (HsFractional _) (HsIntegral _) = GT - compare (HsFractional _) (HsIsString _ _) = LT - compare (HsIsString _ s1) (HsIsString _ s2) = s1 `lexicalCompareFS` s2 - compare (HsIsString _ _) (HsIntegral _) = GT - compare (HsIsString _ _) (HsFractional _) = GT + -- HsIntegral + HsIntegral i1 `compare` HsIntegral i2 = i1 `compare` i2 + HsIntegral{} `compare` HsFractional{} = LT + HsIntegral{} `compare` HsIsString{} = LT + -- HsFractional + HsFractional{} `compare` HsIntegral{} = GT + HsFractional f1 `compare` HsFractional f2 = f1 `compare` f2 + HsFractional{} `compare` HsIsString{} = LT + -- HsIsString + HsIsString{} `compare` HsIntegral{} = GT + HsIsString{} `compare` HsFractional{} = GT + HsIsString _ s1 `compare` HsIsString _ s2 = s1 `lexicalCompareFS` s2 View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/606cf582696b092ec316af59a57dcde… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/606cf582696b092ec316af59a57dcde… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/marge_bot_batch_merge_job] Refactor: make function patterns exhaustive
by Marge Bot (＠marge-bot) 03 Feb '26

03 Feb '26

Marge Bot pushed to branch wip/marge_bot_batch_merge_job at Glasgow Haskell Compiler / GHC Commits: 5f50aa93 by Brandon Chinn at 2026-02-02T19:18:15-05:00 Refactor: make function patterns exhaustive Also added missing (==) logic for: * HsMultilineString * HsInt{8,16,32} * HsWord{8,16,32} - - - - - 2 changed files: - compiler/GHC/ThToHs.hs - compiler/Language/Haskell/Syntax/Lit.hs Changes: ===================================== compiler/GHC/ThToHs.hs ===================================== @@ -1462,10 +1462,11 @@ cvtLit (BytesPrimL (Bytes fptr off sz)) = do BS.packCStringLen (ptr `plusPtr` fromIntegral off, fromIntegral sz) force bs return $ HsStringPrim NoSourceText bs -cvtLit _ = panic "Convert.cvtLit: Unexpected literal" - -- cvtLit should not be called on IntegerL, RationalL - -- That precondition is established right here in - -- "GHC.ThToHs", hence panic +-- cvtLit should not be called on IntegerL, RationalL +-- That precondition is established right here in +-- "GHC.ThToHs", hence panic +cvtLit (IntegerL _) = panic "Convert.cvtLit: Unexpected literal" +cvtLit (RationalL _) = panic "Convert.cvtLit: Unexpected literal" quotedSourceText :: String -> SourceText quotedSourceText s = SourceText $ fsLit $ "\"" ++ s ++ "\"" ===================================== compiler/Language/Haskell/Syntax/Lit.hs ===================================== @@ -79,19 +79,44 @@ data HsLit x | XLit !(XXLit x) instance (Eq (XXLit x)) => Eq (HsLit x) where - (HsChar _ x1) == (HsChar _ x2) = x1==x2 - (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2 - (HsString _ x1) == (HsString _ x2) = x1==x2 - (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2 - (HsInt _ x1) == (HsInt _ x2) = x1==x2 - (HsIntPrim _ x1) == (HsIntPrim _ x2) = x1==x2 - (HsWordPrim _ x1) == (HsWordPrim _ x2) = x1==x2 - (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2 - (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2 - (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2 - (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2 - (XLit x1) == (XLit x2) = x1==x2 - _ == _ = False + HsChar _ x1 == HsChar _ x2 = x1 == x2 + HsChar{} == _ = False + HsCharPrim _ x1 == HsCharPrim _ x2 = x1 == x2 + HsCharPrim{} == _ = False + HsString _ x1 == HsString _ x2 = x1 == x2 + HsString{} == _ = False + HsMultilineString _ x1 == HsMultilineString _ x2 = x1 == x2 + HsMultilineString{} == _ = False + HsStringPrim _ x1 == HsStringPrim _ x2 = x1 == x2 + HsStringPrim{} == _ = False + HsInt _ x1 == HsInt _ x2 = x1 == x2 + HsInt{} == _ = False + HsIntPrim _ x1 == HsIntPrim _ x2 = x1 == x2 + HsIntPrim{} == _ = False + HsWordPrim _ x1 == HsWordPrim _ x2 = x1 == x2 + HsWordPrim{} == _ = False + HsInt8Prim _ x1 == HsInt8Prim _ x2 = x1 == x2 + HsInt8Prim{} == _ = False + HsInt16Prim _ x1 == HsInt16Prim _ x2 = x1 == x2 + HsInt16Prim{} == _ = False + HsInt32Prim _ x1 == HsInt32Prim _ x2 = x1 == x2 + HsInt32Prim{} == _ = False + HsInt64Prim _ x1 == HsInt64Prim _ x2 = x1 == x2 + HsInt64Prim{} == _ = False + HsWord8Prim _ x1 == HsWord8Prim _ x2 = x1 == x2 + HsWord8Prim{} == _ = False + HsWord16Prim _ x1 == HsWord16Prim _ x2 = x1 == x2 + HsWord16Prim{} == _ = False + HsWord32Prim _ x1 == HsWord32Prim _ x2 = x1 == x2 + HsWord32Prim{} == _ = False + HsWord64Prim _ x1 == HsWord64Prim _ x2 = x1 == x2 + HsWord64Prim{} == _ = False + HsFloatPrim _ x1 == HsFloatPrim _ x2 = x1 == x2 + HsFloatPrim{} == _ = False + HsDoublePrim _ x1 == HsDoublePrim _ x2 = x1 == x2 + HsDoublePrim{} == _ = False + XLit x1 == XLit x2 = x1 == x2 + XLit{} == _ = False -- | Haskell Overloaded Literal data HsOverLit p @@ -112,18 +137,23 @@ data OverLitVal deriving Data instance Eq OverLitVal where - (HsIntegral i1) == (HsIntegral i2) = i1 == i2 - (HsFractional f1) == (HsFractional f2) = f1 == f2 - (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2 - _ == _ = False + HsIntegral i1 == HsIntegral i2 = i1 == i2 + HsIntegral{} == _ = False + HsFractional f1 == HsFractional f2 = f1 == f2 + HsFractional{} == _ = False + HsIsString _ s1 == HsIsString _ s2 = s1 == s2 + HsIsString{} == _ = False instance Ord OverLitVal where - compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2 - compare (HsIntegral _) (HsFractional _) = LT - compare (HsIntegral _) (HsIsString _ _) = LT - compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2 - compare (HsFractional _) (HsIntegral _) = GT - compare (HsFractional _) (HsIsString _ _) = LT - compare (HsIsString _ s1) (HsIsString _ s2) = s1 `lexicalCompareFS` s2 - compare (HsIsString _ _) (HsIntegral _) = GT - compare (HsIsString _ _) (HsFractional _) = GT + -- HsIntegral + HsIntegral i1 `compare` HsIntegral i2 = i1 `compare` i2 + HsIntegral{} `compare` HsFractional{} = LT + HsIntegral{} `compare` HsIsString{} = LT + -- HsFractional + HsFractional{} `compare` HsIntegral{} = GT + HsFractional f1 `compare` HsFractional f2 = f1 `compare` f2 + HsFractional{} `compare` HsIsString{} = LT + -- HsIsString + HsIsString{} `compare` HsIntegral{} = GT + HsIsString{} `compare` HsFractional{} = GT + HsIsString _ s1 `compare` HsIsString _ s2 = s1 `lexicalCompareFS` s2 View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5f50aa9384da474128963e042cc68d8… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/5f50aa9384da474128963e042cc68d8… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc][wip/marge_bot_batch_merge_job] 4 commits: Include current phase in the range for rule/unfoldings
by Marge Bot (＠marge-bot) 02 Feb '26

02 Feb '26

Marge Bot pushed to branch wip/marge_bot_batch_merge_job at Glasgow Haskell Compiler / GHC Commits: 269c4087 by Simon Peyton Jones at 2026-02-01T19:38:10-05:00 Include current phase in the range for rule/unfoldings This MR fixes a bad loop in the compiler: #26826. The fix is to add (WAR2) to Note [What is active in the RHS of a RULE or unfolding?] in GHC.Core.Opt.Simplify.Utils - - - - - ddf1434f by Vladislav Zavialov at 2026-02-01T19:38:52-05:00 Refactor: merge HsMultilineString into HsString (#26860) Before this patch, HsLit defined two separate constructors to represent single-line and multi-line strings: data HsLit x ... | HsString (XHsString x) FastString | HsMultilineString (XHsMultilineString x) FastString I found this to be an unnecessary complication and an obstacle to unifying HsLit with HsTyLit. Now we use HsString for both kinds of literals. One user-facing change here is `ppr (HsString st s)` behaving differently for single-line strings containing newlines: x = "first line \ \asdf\n\ \second line" Previously, the literal was fed to `ftext` with its newlines, producing an ill-formed SDoc. This issue is now addressed by using `split` for both single-line and multi-line strings: vcat $ map text $ split '\n' (unpackFS src) See the parser/should_fail/T26860ppr test. In addition (and unrelatedly to the main payload of this patch), drop the unused pmPprHsLit helper. - - - - - 2b4f463c by Simon Peyton Jones at 2026-02-02T17:32:32+00:00 Remove exprIsCheap from doFloatFromRhs See #26854 and Note [Float when expandable] This patch simplifies the code, by removing an extra unnecessary test. - - - - - f453623d by Brandon Chinn at 2026-02-02T16:47:03-05:00 Refactor: make function patterns exhaustive Also added missing (==) logic for: * HsMultilineString * HsInt{8,16,32} * HsWord{8,16,32} - - - - - 22 changed files: - compiler/GHC/Core/Opt/OccurAnal.hs - compiler/GHC/Core/Opt/Simplify/Env.hs - compiler/GHC/Core/Opt/Simplify/Utils.hs - compiler/GHC/Core/Opt/WorkWrap.hs - compiler/GHC/Hs/Lit.hs - compiler/GHC/Hs/Syn/Type.hs - compiler/GHC/HsToCore/Match/Literal.hs - compiler/GHC/HsToCore/Quote.hs - compiler/GHC/Parser.y - compiler/GHC/Parser/String.hs - compiler/GHC/Rename/Expr.hs - compiler/GHC/Tc/Gen/HsType.hs - compiler/GHC/ThToHs.hs - compiler/GHC/Types/InlinePragma.hs - compiler/Language/Haskell/Syntax/Extension.hs - compiler/Language/Haskell/Syntax/Lit.hs - + testsuite/tests/parser/should_fail/T26860ppr.hs - + testsuite/tests/parser/should_fail/T26860ppr.stderr - testsuite/tests/parser/should_fail/all.T - + testsuite/tests/simplCore/should_compile/T26826.hs - testsuite/tests/simplCore/should_compile/all.T - utils/check-exact/ExactPrint.hs Changes: ===================================== compiler/GHC/Core/Opt/OccurAnal.hs ===================================== @@ -1417,16 +1417,17 @@ then we *must* choose f to be a loop breaker. Example: see Note That is the whole reason for computing rule_fv_env in mkLoopBreakerNodes. Wrinkles: -* We only consider /active/ rules. See Note [Finding rule RHS free vars] +(RLB1) We only consider /active/ rules. + This is important: see Note [Finding rule RHS free vars] -* We need only consider free vars that are also binders in this Rec +(RLB2) We need only consider free vars that are also binders in this Rec group. See also Note [Finding rule RHS free vars] -* We only consider variables free in the *RHS* of the rule, in +(RLB3) We only consider variables free in the *RHS* of the rule, in contrast to the way we build the Rec group in the first place (Note [Rule dependency info]) -* Why "transitive sequence of rules"? Because active rules apply +(RLB4) Why "transitive sequence of rules"? Because active rules apply unconditionally, without checking loop-breaker-ness. See Note [Loop breaker dependencies]. @@ -1854,10 +1855,13 @@ makeNode !env imp_rule_edges bndr_set (bndr, rhs) add_rule_uds (_, l, r) uds = l `andUDs` r `andUDs` uds -------- active_rule_fvs ------------ + -- See Note [Rules and loop breakers] active_rule_fvs = foldr add_active_rule imp_rule_fvs rules_w_uds add_active_rule (rule, _, rhs_uds) fvs - | is_active (ruleActivation rule) + | is_active (ruleActivation rule) -- See (RLB1) = udFreeVars bndr_set rhs_uds `unionVarSet` fvs + -- Only consider the `rhs_uss`, not the LHS ones; see (RLB3) + -- udFreeVars restricts to bndr_set; see (RLB2) | otherwise = fvs ===================================== compiler/GHC/Core/Opt/Simplify/Env.hs ===================================== @@ -12,7 +12,7 @@ module GHC.Core.Opt.Simplify.Env ( -- * Environments SimplEnv(..), pprSimplEnv, -- Temp not abstract - SimplPhase(..), isActive, + SimplPhase(..), isActive, simplStartPhase, simplEndPhase, seArityOpts, seCaseCase, seCaseFolding, seCaseMerge, seCastSwizzle, seDoEtaReduction, seEtaExpand, seFloatEnable, seInline, seNames, seOptCoercionOpts, sePhase, sePlatform, sePreInline, @@ -293,7 +293,9 @@ data SimplMode = SimplMode -- See comments in GHC.Core.Opt.Simplify.Monad -- | See Note [SimplPhase] data SimplPhase -- | A simplifier phase: InitialPhase, Phase 2, Phase 1, Phase 0, FinalPhase + -- NB: (SimplPhase p) is equivalent to (SimplPhaseRange p p) = SimplPhase CompilerPhase + -- | Simplifying the RHS of a rule or of a stable unfolding: the range of -- phases of the activation of the rule/stable unfolding. -- @@ -302,13 +304,18 @@ data SimplPhase -- -- See Note [What is active in the RHS of a RULE or unfolding?] -- in GHC.Core.Opt.Simplify.Utils. - | SimplPhaseRange - { simplStartPhase :: CompilerPhase - , simplEndPhase :: CompilerPhase - } + | SimplPhaseRange CompilerPhase CompilerPhase deriving Eq +simplStartPhase :: SimplPhase -> CompilerPhase +simplStartPhase (SimplPhase p) = p +simplStartPhase (SimplPhaseRange p _) = p + +simplEndPhase :: SimplPhase -> CompilerPhase +simplEndPhase (SimplPhase p) = p +simplEndPhase (SimplPhaseRange _ p) = p + instance Outputable SimplPhase where ppr (SimplPhase p) = ppr p ppr (SimplPhaseRange s e) = brackets $ ppr s <> ellipsis <> ppr e @@ -322,12 +329,13 @@ instance Outputable SimplPhase where -- -- See Note [SimplPhase]. isActive :: SimplPhase -> ActivationGhc -> Bool -isActive (SimplPhase p) act = isActiveInPhase p act -isActive (SimplPhaseRange start end) act = - -- To check whether the activation is active throughout the whole phase range, - -- it's sufficient to check the endpoints of the phase range, because an - -- activation can never have gaps (all activations are phase intervals). - isActiveInPhase start act && isActiveInPhase end act +isActive (SimplPhase p) act + = isActiveInPhase p act +isActive (SimplPhaseRange start end) act + = -- To check whether the activation is active throughout the whole phase range, + -- it's sufficient to check the endpoints of the phase range, because an + -- activation can never have gaps (all activations are phase intervals). + isActiveInPhase start act && isActiveInPhase end act {- Note [SimplPhase] ~~~~~~~~~~~~~~~~~~~~ @@ -807,8 +815,9 @@ doFloatFromRhs fe lvl rec strict_bind (SimplFloats { sfLetFloats = LetFloats fs && want_to_float && can_float where - want_to_float = isTopLevel lvl || exprIsCheap rhs || exprIsExpandable rhs - -- See Note [Float when cheap or expandable] + want_to_float = isTopLevel lvl || exprIsExpandable rhs + -- See Note [Float when expandable] + can_float = case ff of FltLifted -> True FltOkSpec -> isNotTopLevel lvl && isNonRec rec @@ -820,16 +829,29 @@ doFloatFromRhs fe lvl rec strict_bind (SimplFloats { sfLetFloats = LetFloats fs floatEnabled lvl FloatNestedOnly = not (isTopLevel lvl) floatEnabled _ FloatEnabled = True -{- -Note [Float when cheap or expandable] -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -We want to float a let from a let if the residual RHS is - a) cheap, such as (\x. blah) - b) expandable, such as (f b) if f is CONLIKE -But there are - - cheap things that are not expandable (eg \x. expensive) - - expandable things that are not cheap (eg (f b) where b is CONLIKE) -so we must take the 'or' of the two. +{- Note [Float when expandable] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +We float when that would leave us with a RHS that is /expandable/ (#26854). +The whole purpose of the local-let-floating is to end up with + let x = rhs +where rhs has an expandable unfolding, so that `exprIsConApp_maybe` will look +inside `x`. + +Historical aside: + + In the long-distant (2011) past, we made `want_to_float` true if + EITHER exprIsExpandable OR exprIsCheap + But that seems wrong: there is no point in floating for expressions that are + cheap but not expandable: + * It costs more to test + * It gives no benefit + * Very few expressions are cheap but not expandable (e.g. error calls) + We justified this OR by saying that there may be: + - cheap things that are not expandable (eg \x. expensive) + - expandable things that are not cheap (eg (f b) where b is CONLIKE) + But that's not true: (\x.expensive) is certainly expandable. + +End of historial aside -} emptyLetFloats :: LetFloats ===================================== compiler/GHC/Core/Opt/Simplify/Utils.hs ===================================== @@ -1099,7 +1099,7 @@ updModeForStableUnfoldings :: ActivationGhc -> SimplMode -> SimplMode -- See Note [Simplifying inside stable unfoldings] updModeForStableUnfoldings unf_act current_mode = current_mode - { sm_phase = phaseFromActivation (sm_phase current_mode) unf_act + { sm_phase = phaseForRuleOrUnf (sm_phase current_mode) unf_act -- See Note [What is active in the RHS of a RULE or unfolding?] , sm_eta_expand = False -- See Note [Eta expansion in stable unfoldings and rules] @@ -1123,27 +1123,32 @@ updModeForRuleRHS :: ActivationGhc -> SimplMode -> SimplMode updModeForRuleRHS rule_act current_mode = current_mode -- See Note [What is active in the RHS of a RULE or unfolding?] - { sm_phase = phaseFromActivation (sm_phase current_mode) rule_act + { sm_phase = phaseForRuleOrUnf (sm_phase current_mode) rule_act , sm_eta_expand = False -- See Note [Eta expansion in stable unfoldings and rules] } --- | Compute the phase range to set the 'SimplMode' to --- when simplifying the RHS of a rule or of a stable unfolding. +-- | `phaseForRuleOrUnf` computes the phase range to use when +-- simplifying the RHS of a rule or of a stable unfolding. -- +-- This subtle function implements the careful plan described in -- See Note [What is active in the RHS of a RULE or unfolding?] -phaseFromActivation - :: SimplPhase -- ^ the current simplifier phase +phaseForRuleOrUnf + :: SimplPhase -- ^ the current simplifier phase -> ActivationGhc -- ^ the activation of the RULE or stable unfolding -> SimplPhase -phaseFromActivation p act - | isNeverActive act - = p +phaseForRuleOrUnf current_phase act + | start == end + = SimplPhase start | otherwise - = SimplPhaseRange act_start act_end + = SimplPhaseRange start end where - act_start = beginPhase act - act_end = endPhase act + start, end :: CompilerPhase + start = beginPhase act `earliestPhase` simplStartPhase current_phase + end = endPhase act `latestPhase` simplEndPhase current_phase + -- The beginPhase/endPhase implements (WAR1) + -- The simplStartPhase/simplEndPhase implements (WAR2) + -- of Note [What is active in the RHS of a RULE or unfolding?] {- Note [Simplifying rules] ~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -1275,26 +1280,47 @@ Our carefully crafted plan is as follows: ------------------------------------------------------------- When simplifying the RHS of a RULE R with activation range A, - fire only other rules R' that are active throughout all of A. + fire only other rules R' that are active + (WAR1) throughout all of A + (WAR2) in the current phase + See `phaseForRuleOrUnf`. ------------------------------------------------------------- -Reason: R might fire in any phase in A. Then R' can fire only if R' is active -in that phase. If not, it's not safe to unconditionally fire R' in the RHS of R. +Reasons for (WAR1): + * R might fire in any phase in A. Then R' can fire only if R' is active in that + phase. If not, it's not safe to unconditionally fire R' in the RHS of R. + +Reasons for (WAR2): + * If A is empty (e.g. a NOINLINE pragma, so the unfolding is never active) + we don't want to vacuously satisfy (WAR1) and thereby fire /all/ RULES in + the unfolding. Two RULES may be crafted so that they are never simultaneously + active, and will loop if they are. + + * Suppose we are in Phase 2, looking at a stable unfolding for INLINE [1]. + If we just do (WAR1) we will fire RULES active in phase 1; but the + occurrence analyser ignores any rules not active in the current phase. + So occ-anal may fail to detect a loop breaker; see #26826 for details. + See Note [Rules and loop breakers] in GHC.Core.Opt.OccurAnal. + + * Aesthetically, this means that when the simplifer is in phase N, it + won't switch to a phase-range that doesn't include N (e.g. might be later + than N). This is what caused #26826. + + * Also note that as the current phase advances, it'll eventually be inside + the range specified by (WAR1), and hence will not widen the range. + Unless the latter is empty, of course. This plan is implemented by: - 1. Setting the simplifier phase to the range of phases - corresponding to the start/end phases of the rule's activation. + 1. Setting the simplifier phase to the /range/ of phases + corresponding to the start/end phases of the rule's activation, implementing + (WAR1) and (WAR2). This happens in `phaseForRuleOrUnf`. + 2. When checking whether another rule is active, we use the function isActive :: SimplPhase -> Activation -> Bool from GHC.Core.Opt.Simplify.Env, which checks whether the other rule is active throughout the whole range of phases. -However, if the rule whose RHS we are simplifying is never active, instead of -setting the phase range to an empty interval, we keep the current simplifier -phase. This special case avoids firing ALL rules in the RHS of a never-active -rule. - You might wonder about a situation such as the following: module M1 where @@ -1307,6 +1333,7 @@ It looks tempting to use "r1" when simplifying the RHS of "r2", yet we **must not** do so: for any module M that imports M1, we are going to start simplification in M starting at InitialPhase, and we will see the fully simplified rules RHSs imported from M1. + Conclusion: stick to the plan. Note [Simplifying inside stable unfoldings] ===================================== compiler/GHC/Core/Opt/WorkWrap.hs ===================================== @@ -914,9 +914,9 @@ mkStrWrapperInlinePrag (InlinePragma { inl_inline = fn_inl where srcTxt = SourceText $ fsLit "{-# INLINE" -- See Note [Wrapper activation] - wrapper_phase = foldr (laterPhase . get_rule_phase) earliest_inline_phase rules - earliest_inline_phase = beginPhase fn_act `laterPhase` nextPhase InitialPhase - -- laterPhase (nextPhase InitialPhase) is a temporary hack + wrapper_phase = foldr (latestPhase . get_rule_phase) earliest_inline_phase rules + earliest_inline_phase = beginPhase fn_act `latestPhase` nextPhase InitialPhase + -- latestPhase (nextPhase InitialPhase) is a temporary hack -- to inline no earlier than phase 2. I got regressions in -- 'mate', due to changes in full laziness due to Note [Case -- MFEs], when I did earlier inlining. ===================================== compiler/GHC/Hs/Lit.hs ===================================== @@ -45,7 +45,6 @@ import Language.Haskell.Syntax.Lit type instance XHsChar (GhcPass _) = SourceText type instance XHsCharPrim (GhcPass _) = SourceText type instance XHsString (GhcPass _) = SourceText -type instance XHsMultilineString (GhcPass _) = SourceText type instance XHsStringPrim (GhcPass _) = SourceText type instance XHsInt (GhcPass _) = NoExtField type instance XHsIntPrim (GhcPass _) = SourceText @@ -147,7 +146,6 @@ hsLitNeedsParens p = go go (HsChar {}) = False go (HsCharPrim {}) = False go (HsString {}) = False - go (HsMultilineString {}) = False go (HsStringPrim {}) = False go (HsInt _ x) = p > topPrec && il_neg x go (HsFloatPrim {}) = False @@ -177,7 +175,6 @@ convertLit :: XXLit (GhcPass p)~DataConCantHappen => HsLit (GhcPass p) -> HsLit convertLit (HsChar a x) = HsChar a x convertLit (HsCharPrim a x) = HsCharPrim a x convertLit (HsString a x) = HsString a x -convertLit (HsMultilineString a x) = HsMultilineString a x convertLit (HsStringPrim a x) = HsStringPrim a x convertLit (HsInt a x) = HsInt a x convertLit (HsIntPrim a x) = HsIntPrim a x @@ -212,8 +209,7 @@ Equivalently it's True if instance IsPass p => Outputable (HsLit (GhcPass p)) where ppr (HsChar st c) = pprWithSourceText st (pprHsChar c) ppr (HsCharPrim st c) = pprWithSourceText st (pprPrimChar c) - ppr (HsString st s) = pprWithSourceText st (pprHsString s) - ppr (HsMultilineString st s) = + ppr (HsString st s) = case st of NoSourceText -> pprHsString s SourceText src -> vcat $ map text $ split '\n' (unpackFS src) @@ -248,36 +244,6 @@ instance Outputable OverLitVal where ppr (HsFractional f) = ppr f ppr (HsIsString st s) = pprWithSourceText st (pprHsString s) --- | pmPprHsLit pretty prints literals and is used when pretty printing pattern --- match warnings. All are printed the same (i.e., without hashes if they are --- primitive and not wrapped in constructors if they are boxed). This happens --- mainly for too reasons: --- * We do not want to expose their internal representation --- * The warnings become too messy -pmPprHsLit :: forall p. IsPass p => HsLit (GhcPass p) -> SDoc -pmPprHsLit (HsChar _ c) = pprHsChar c -pmPprHsLit (HsCharPrim _ c) = pprHsChar c -pmPprHsLit (HsString st s) = pprWithSourceText st (pprHsString s) -pmPprHsLit (HsMultilineString st s) = pprWithSourceText st (pprHsString s) -pmPprHsLit (HsStringPrim _ s) = pprHsBytes s -pmPprHsLit (HsInt _ i) = integer (il_value i) -pmPprHsLit (HsIntPrim _ i) = integer i -pmPprHsLit (HsWordPrim _ w) = integer w -pmPprHsLit (HsInt8Prim _ i) = integer i -pmPprHsLit (HsInt16Prim _ i) = integer i -pmPprHsLit (HsInt32Prim _ i) = integer i -pmPprHsLit (HsInt64Prim _ i) = integer i -pmPprHsLit (HsWord8Prim _ w) = integer w -pmPprHsLit (HsWord16Prim _ w) = integer w -pmPprHsLit (HsWord32Prim _ w) = integer w -pmPprHsLit (HsWord64Prim _ w) = integer w -pmPprHsLit (HsFloatPrim _ f) = ppr f -pmPprHsLit (HsDoublePrim _ d) = ppr d -pmPprHsLit (XLit x) = case ghcPass @p of - GhcTc -> case x of - (HsInteger _ i _) -> integer i - (HsRat f _) -> ppr f - negateOverLitVal :: OverLitVal -> OverLitVal negateOverLitVal (HsIntegral i) = HsIntegral (negateIntegralLit i) negateOverLitVal (HsFractional f) = HsFractional (negateFractionalLit f) ===================================== compiler/GHC/Hs/Syn/Type.hs ===================================== @@ -75,7 +75,6 @@ hsLitType :: forall p. IsPass p => HsLit (GhcPass p) -> Type hsLitType (HsChar _ _) = charTy hsLitType (HsCharPrim _ _) = charPrimTy hsLitType (HsString _ _) = stringTy -hsLitType (HsMultilineString _ _) = stringTy hsLitType (HsStringPrim _ _) = addrPrimTy hsLitType (HsInt _ _) = intTy hsLitType (HsIntPrim _ _) = intPrimTy ===================================== compiler/GHC/HsToCore/Match/Literal.hs ===================================== @@ -117,7 +117,6 @@ dsLit l = do HsDoublePrim _ fl -> return (Lit (LitDouble (rationalFromFractionalLit fl))) HsChar _ c -> return (mkCharExpr c) HsString _ str -> mkStringExprFS str - HsMultilineString _ str -> mkStringExprFS str HsInt _ i -> return (mkIntExpr platform (il_value i)) XLit x -> case ghcPass @p of GhcTc -> case x of @@ -463,7 +462,6 @@ getSimpleIntegralLit (XLit (HsInteger _ i ty)) = Just (i, ty) getSimpleIntegralLit HsChar{} = Nothing getSimpleIntegralLit HsCharPrim{} = Nothing getSimpleIntegralLit HsString{} = Nothing -getSimpleIntegralLit HsMultilineString{} = Nothing getSimpleIntegralLit HsStringPrim{} = Nothing getSimpleIntegralLit (XLit (HsRat{})) = Nothing getSimpleIntegralLit HsFloatPrim{} = Nothing ===================================== compiler/GHC/HsToCore/Quote.hs ===================================== @@ -3077,7 +3077,6 @@ repLiteral lit HsChar _ _ -> Just charLName HsCharPrim _ _ -> Just charPrimLName HsString _ _ -> Just stringLName - HsMultilineString _ _ -> Just stringLName _ -> Nothing mk_integer :: Integer -> MetaM (HsLit GhcTc) ===================================== compiler/GHC/Parser.y ===================================== @@ -4131,7 +4131,7 @@ literal :: { Located (HsLit GhcPs) } : CHAR { sL1 $1 $ HsChar (getCHARs $1) $ getCHAR $1 } | STRING { sL1 $1 $ HsString (getSTRINGs $1) $ getSTRING $1 } - | STRING_MULTI { sL1 $1 $ HsMultilineString (getSTRINGMULTIs $1) + | STRING_MULTI { sL1 $1 $ HsString (getSTRINGMULTIs $1) $ getSTRINGMULTI $1 } | PRIMINTEGER { sL1 $1 $ HsIntPrim (getPRIMINTEGERs $1) $ getPRIMINTEGER $1 } ===================================== compiler/GHC/Parser/String.hs ===================================== @@ -392,9 +392,9 @@ proposal: https://github.com/ghc-proposals/ghc-proposals/pull/569 Multiline string literals are syntax sugar for normal string literals, with an extra post processing step. This all happens in the Lexer; that -is, HsMultilineString will contain the post-processed string. This matches -the same behavior as HsString, which contains the normalized string -(see Note [Literal source text]). +is, the multi-line HsString will contain the post-processed string. +This matches the behavior of the single-line HsString, which contains +the normalized string too (see Note [Literal source text]). The canonical steps for post processing a multiline string are: 1. Collapse string gaps ===================================== compiler/GHC/Rename/Expr.hs ===================================== @@ -352,18 +352,13 @@ rnExpr (HsOverLabel src v) hs_ty_arg = mkEmptyWildCardBndrs $ wrapGenSpan $ HsTyLit noExtField (HsStrTy NoSourceText v) -rnExpr (HsLit x lit) | Just (src, s) <- stringLike lit +rnExpr (HsLit x lit) | HsString src s <- lit = do { opt_OverloadedStrings <- xoptM LangExt.OverloadedStrings ; if opt_OverloadedStrings then rnExpr (HsOverLit x (mkHsIsString src s)) else do { ; rnLit lit ; return (HsLit x (convertLit lit), emptyFVs) } } - where - stringLike = \case - HsString src s -> Just (src, s) - HsMultilineString src s -> Just (src, s) - _ -> Nothing rnExpr (HsLit x lit) = do { rnLit lit ===================================== compiler/GHC/Tc/Gen/HsType.hs ===================================== @@ -4786,7 +4786,6 @@ promotionErr name err tyLitFromLit :: HsLit GhcRn -> Maybe (HsTyLit GhcRn) tyLitFromLit (HsString x str) = Just (HsStrTy x str) -tyLitFromLit (HsMultilineString x str) = Just (HsStrTy x str) tyLitFromLit (HsChar x char) = Just (HsCharTy x char) tyLitFromLit _ = Nothing ===================================== compiler/GHC/ThToHs.hs ===================================== @@ -1462,10 +1462,11 @@ cvtLit (BytesPrimL (Bytes fptr off sz)) = do BS.packCStringLen (ptr `plusPtr` fromIntegral off, fromIntegral sz) force bs return $ HsStringPrim NoSourceText bs -cvtLit _ = panic "Convert.cvtLit: Unexpected literal" - -- cvtLit should not be called on IntegerL, RationalL - -- That precondition is established right here in - -- "GHC.ThToHs", hence panic +-- cvtLit should not be called on IntegerL, RationalL +-- That precondition is established right here in +-- "GHC.ThToHs", hence panic +cvtLit (IntegerL _) = panic "Convert.cvtLit: Unexpected literal" +cvtLit (RationalL _) = panic "Convert.cvtLit: Unexpected literal" quotedSourceText :: String -> SourceText quotedSourceText s = SourceText $ fsLit $ "\"" ++ s ++ "\"" ===================================== compiler/GHC/Types/InlinePragma.hs ===================================== @@ -104,9 +104,8 @@ module GHC.Types.InlinePragma , endPhase -- *** Queries , isActiveInPhase - , laterPhase - , laterThanPhase - , nextPhase + , latestPhase, earliestPhase + , laterThanPhase, nextPhase ) where import GHC.Prelude @@ -422,13 +421,21 @@ nextPhase (Phase 0) = FinalPhase nextPhase (Phase n) = Phase (n-1) nextPhase FinalPhase = FinalPhase -laterPhase :: CompilerPhase -> CompilerPhase -> CompilerPhase --- ^ Returns the later of two phases -laterPhase (Phase n1) (Phase n2) = Phase (n1 `min` n2) -laterPhase InitialPhase p2 = p2 -laterPhase FinalPhase _ = FinalPhase -laterPhase p1 InitialPhase = p1 -laterPhase _ FinalPhase = FinalPhase +earliestPhase :: CompilerPhase -> CompilerPhase -> CompilerPhase +-- ^ Returns the earliest of two phases +earliestPhase (Phase n1) (Phase n2) = Phase (n1 `max` n2) +earliestPhase InitialPhase _ = InitialPhase +earliestPhase FinalPhase p2 = p2 +earliestPhase _ InitialPhase = InitialPhase +earliestPhase p1 FinalPhase = p1 + +latestPhase :: CompilerPhase -> CompilerPhase -> CompilerPhase +-- ^ Returns the latest of two phases +latestPhase (Phase n1) (Phase n2) = Phase (n1 `min` n2) +latestPhase InitialPhase p2 = p2 +latestPhase FinalPhase _ = FinalPhase +latestPhase p1 InitialPhase = p1 +latestPhase _ FinalPhase = FinalPhase -- | @p1 `laterThanOrEqualPhase` p2@ computes whether @p1@ happens (strictly) -- after @p2@. ===================================== compiler/Language/Haskell/Syntax/Extension.hs ===================================== @@ -609,7 +609,6 @@ type family XXParStmtBlock x x' type family XHsChar x type family XHsCharPrim x type family XHsString x -type family XHsMultilineString x type family XHsStringPrim x type family XHsInt x type family XHsIntPrim x ===================================== compiler/Language/Haskell/Syntax/Lit.hs ===================================== @@ -47,8 +47,6 @@ data HsLit x -- ^ Unboxed character | HsString (XHsString x) {- SourceText -} FastString -- ^ String - | HsMultilineString (XHsMultilineString x) {- SourceText -} FastString - -- ^ String | HsStringPrim (XHsStringPrim x) {- SourceText -} !ByteString -- ^ Packed bytes | HsInt (XHsInt x) IntegralLit @@ -81,19 +79,44 @@ data HsLit x | XLit !(XXLit x) instance (Eq (XXLit x)) => Eq (HsLit x) where - (HsChar _ x1) == (HsChar _ x2) = x1==x2 - (HsCharPrim _ x1) == (HsCharPrim _ x2) = x1==x2 - (HsString _ x1) == (HsString _ x2) = x1==x2 - (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2 - (HsInt _ x1) == (HsInt _ x2) = x1==x2 - (HsIntPrim _ x1) == (HsIntPrim _ x2) = x1==x2 - (HsWordPrim _ x1) == (HsWordPrim _ x2) = x1==x2 - (HsInt64Prim _ x1) == (HsInt64Prim _ x2) = x1==x2 - (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2 - (HsFloatPrim _ x1) == (HsFloatPrim _ x2) = x1==x2 - (HsDoublePrim _ x1) == (HsDoublePrim _ x2) = x1==x2 - (XLit x1) == (XLit x2) = x1==x2 - _ == _ = False + HsChar _ x1 == HsChar _ x2 = x1 == x2 + HsChar{} == _ = False + HsCharPrim _ x1 == HsCharPrim _ x2 = x1 == x2 + HsCharPrim{} == _ = False + HsString _ x1 == HsString _ x2 = x1 == x2 + HsString{} == _ = False + HsMultilineString _ x1 == HsMultilineString _ x2 = x1 == x2 + HsMultilineString{} == _ = False + HsStringPrim _ x1 == HsStringPrim _ x2 = x1 == x2 + HsStringPrim{} == _ = False + HsInt _ x1 == HsInt _ x2 = x1 == x2 + HsInt{} == _ = False + HsIntPrim _ x1 == HsIntPrim _ x2 = x1 == x2 + HsIntPrim{} == _ = False + HsWordPrim _ x1 == HsWordPrim _ x2 = x1 == x2 + HsWordPrim{} == _ = False + HsInt8Prim _ x1 == HsInt8Prim _ x2 = x1 == x2 + HsInt8Prim{} == _ = False + HsInt16Prim _ x1 == HsInt16Prim _ x2 = x1 == x2 + HsInt16Prim{} == _ = False + HsInt32Prim _ x1 == HsInt32Prim _ x2 = x1 == x2 + HsInt32Prim{} == _ = False + HsInt64Prim _ x1 == HsInt64Prim _ x2 = x1 == x2 + HsInt64Prim{} == _ = False + HsWord8Prim _ x1 == HsWord8Prim _ x2 = x1 == x2 + HsWord8Prim{} == _ = False + HsWord16Prim _ x1 == HsWord16Prim _ x2 = x1 == x2 + HsWord16Prim{} == _ = False + HsWord32Prim _ x1 == HsWord32Prim _ x2 = x1 == x2 + HsWord32Prim{} == _ = False + HsWord64Prim _ x1 == HsWord64Prim _ x2 = x1 == x2 + HsWord64Prim{} == _ = False + HsFloatPrim _ x1 == HsFloatPrim _ x2 = x1 == x2 + HsFloatPrim{} == _ = False + HsDoublePrim _ x1 == HsDoublePrim _ x2 = x1 == x2 + HsDoublePrim{} == _ = False + XLit x1 == XLit x2 = x1 == x2 + XLit{} == _ = False -- | Haskell Overloaded Literal data HsOverLit p @@ -114,18 +137,23 @@ data OverLitVal deriving Data instance Eq OverLitVal where - (HsIntegral i1) == (HsIntegral i2) = i1 == i2 - (HsFractional f1) == (HsFractional f2) = f1 == f2 - (HsIsString _ s1) == (HsIsString _ s2) = s1 == s2 - _ == _ = False + HsIntegral i1 == HsIntegral i2 = i1 == i2 + HsIntegral{} == _ = False + HsFractional f1 == HsFractional f2 = f1 == f2 + HsFractional{} == _ = False + HsIsString _ s1 == HsIsString _ s2 = s1 == s2 + HsIsString{} == _ = False instance Ord OverLitVal where - compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2 - compare (HsIntegral _) (HsFractional _) = LT - compare (HsIntegral _) (HsIsString _ _) = LT - compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2 - compare (HsFractional _) (HsIntegral _) = GT - compare (HsFractional _) (HsIsString _ _) = LT - compare (HsIsString _ s1) (HsIsString _ s2) = s1 `lexicalCompareFS` s2 - compare (HsIsString _ _) (HsIntegral _) = GT - compare (HsIsString _ _) (HsFractional _) = GT + -- HsIntegral + HsIntegral i1 `compare` HsIntegral i2 = i1 `compare` i2 + HsIntegral{} `compare` HsFractional{} = LT + HsIntegral{} `compare` HsIsString{} = LT + -- HsFractional + HsFractional{} `compare` HsIntegral{} = GT + HsFractional f1 `compare` HsFractional f2 = f1 `compare` f2 + HsFractional{} `compare` HsIsString{} = LT + -- HsIsString + HsIsString{} `compare` HsIntegral{} = GT + HsIsString{} `compare` HsFractional{} = GT + HsIsString _ s1 `compare` HsIsString _ s2 = s1 `lexicalCompareFS` s2 ===================================== testsuite/tests/parser/should_fail/T26860ppr.hs ===================================== @@ -0,0 +1,11 @@ +{-# LANGUAGE NoOverloadedStrings #-} + +module T26860ppr where + +-- Test that the error message containing the string literal is well-formatted. +-- See also: parser/should_fail/MultilineStringsError +x :: Int +x = "first line \ + \asdf\n\ + \second line" + ===================================== testsuite/tests/parser/should_fail/T26860ppr.stderr ===================================== @@ -0,0 +1,13 @@ +T26860ppr.hs:8:5: error: [GHC-83865] + • Couldn't match type ‘[Char]’ with ‘Int’ + Expected: Int + Actual: String + • In the expression: + "first line \ + \asdf\n\ + \second line" + In an equation for ‘x’: + x = "first line \ + \asdf\n\ + \second line" + ===================================== testsuite/tests/parser/should_fail/all.T ===================================== @@ -244,3 +244,4 @@ test('T25530', normal, compile_fail, ['']) test('T26418', normal, compile_fail, ['']) test('T12488c', normal, compile_fail, ['']) test('T12488d', normal, compile_fail, ['']) +test('T26860ppr', normal, compile_fail, ['']) ===================================== testsuite/tests/simplCore/should_compile/T26826.hs ===================================== @@ -0,0 +1,86 @@ +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE CPP #-} +{-# LANGUAGE GADTs #-} +{-# LANGUAGE KindSignatures #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeAbstractions #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE TypeData #-} + +module T26826 where + +import Data.Kind (Type) + +type data AstSpan = + FullSpan | PrimalStepSpan AstSpan | PlainSpan + +data SAstSpan (s :: AstSpan) where + SFullSpan :: SAstSpan FullSpan + SPrimalStepSpan :: SAstSpan s -> SAstSpan (PrimalStepSpan s) + SPlainSpan :: SAstSpan PlainSpan + +class KnownSpan (s :: AstSpan) where + knownSpan :: SAstSpan s + +instance KnownSpan FullSpan where + knownSpan = SFullSpan + +instance KnownSpan s => KnownSpan (PrimalStepSpan s) where + knownSpan = SPrimalStepSpan (knownSpan @s) + +instance KnownSpan PlainSpan where + knownSpan = SPlainSpan + +class ADReady target where + ttlet :: target a -> (target a -> target b) -> target b + ttletPrimal :: target a -> (target a -> target b) -> target b + ttletPlain :: target a -> (target a -> target b) -> target b + tplainPart :: target a -> target a + tfromPlain :: target a -> target a + tprimalPart :: target a -> target a + tfromPrimal :: target a -> target a + +type SpanTargetFam target (s :: AstSpan) (y :: Type) = target y + +type AstEnv target = () + +data AstTensor (s :: AstSpan) (y :: Type) where + AstLet + :: forall a b s1 s2. + KnownSpan s1 + => AstTensor s1 a + -> AstTensor s2 b + -> AstTensor s2 b + + AstPrimalPart :: KnownSpan s' => AstTensor s' a -> AstTensor (PrimalStepSpan s') a + AstFromPrimal :: AstTensor (PrimalStepSpan s') a -> AstTensor s' a + AstPlainPart :: KnownSpan s' => AstTensor s' a -> AstTensor PlainSpan a + AstFromPlain :: AstTensor PlainSpan a -> AstTensor s' a + +interpretAst + :: forall target s y. (ADReady target, KnownSpan s) + => AstEnv target -> AstTensor s y + -> SpanTargetFam target s y +{-# INLINE [1] interpretAst #-} +interpretAst !env + = \case + AstLet @_ @_ @s1 @s2 u v -> + case knownSpan @s1 of + SFullSpan -> + ttlet (interpretAst env u) + (\_w -> interpretAst env v) + SPrimalStepSpan _ -> + ttletPrimal (interpretAst env u) + (\_w -> interpretAst env v) + SPlainSpan -> + ttletPlain (interpretAst env u) + (\_w -> interpretAst env v) + AstPrimalPart a -> + tprimalPart (interpretAst env a) + AstFromPrimal a -> + tfromPrimal (interpretAst env a) + AstPlainPart a -> + tplainPart (interpretAst env a) + AstFromPlain a -> + tfromPlain (interpretAst env a) ===================================== testsuite/tests/simplCore/should_compile/all.T ===================================== @@ -578,4 +578,6 @@ test('T26615', [grep_errmsg(r'fEqList')], multimod_compile, ['T26615', '-O -fsp # T26722: there should be no reboxing in $wg test('T26722', [grep_errmsg(r'SPEC')], compile, ['-O -dno-typeable-binds']) + test('T26805', [grep_errmsg(r'fromInteger')], compile, ['-O -dno-typeable-binds -ddump-simpl -dsuppress-uniques']) +test('T26826', normal, compile, ['-O']) ===================================== utils/check-exact/ExactPrint.hs ===================================== @@ -4794,7 +4794,6 @@ hsLit2String lit = HsChar src v -> toSourceTextWithSuffix src v "" HsCharPrim src p -> toSourceTextWithSuffix src p "" HsString src v -> toSourceTextWithSuffix src v "" - HsMultilineString src v -> toSourceTextWithSuffix src v "" HsStringPrim src v -> toSourceTextWithSuffix src v "" HsInt _ (IL src _ v) -> toSourceTextWithSuffix src v "" HsIntPrim src v -> toSourceTextWithSuffix src v "" View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/f856b07bcbfad98d67c9790e03053a… -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/f856b07bcbfad98d67c9790e03053a… You're receiving this email because of your account on gitlab.haskell.org.

1 0

[Git][ghc/ghc] Pushed new branch wip/T26868
by Simon Peyton Jones (＠simonpj) 02 Feb '26

02 Feb '26

Simon Peyton Jones pushed new branch wip/T26868 at Glasgow Haskell Compiler / GHC -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/tree/wip/T26868 You're receiving this email because of your account on gitlab.haskell.org.

1 0