<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">

<html lang="en">

<head>

<meta content="text/html; charset=US-ASCII" http-equiv="Content-Type">

<title>

GitLab

</title>

<style>img {

max-width: 100%; height: auto;

}

</style>

</head>

<body>

<div class="content">

<h3>

Ben Gamari pushed to branch wip/T18079

at <a href="https://gitlab.haskell.org/ghc/ghc">Glasgow Haskell Compiler / GHC</a>

</h3>

<h4>

Commits:

</h4>

<ul>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b0fbfc7582fb81314dc28a056536737fb5eeaa6e">b0fbfc75</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-04-24T12:07:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Switch order on `GhcMake.IsBoot`

In !1798 we were requested to replace many `Bool`s with this data type.

But those bools had `False` meaning `NotBoot`, so the `Ord` instance

would be flipped if we use this data-type as-is.

Since the planned formally-`Bool` occurrences vastly outnumber the

current occurrences, we figured it would be better to conform the `Ord`

instance to how the `Bool` is used now, fixing any issues, rather than

fix them currently with the bigger refactor later in !1798. That way,

!1798 can be a "pure" refactor with no behavioral changes.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/af332442123878c1b61d236dce46418efcbe8750">af332442</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-26T13:55:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Modules: Utils and Data (#13009)

Update Haddock submodule

Metric Increase:

   haddock.compiler

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cd4434c8e77213bf3e6f83227fd8802c9f2a6fe2">cd4434c8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-26T13:55:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix misleading Ptr phantom type in SerializedCompact (#15653)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/22bf5c738e0339fa12940414d6448896c6733808">22bf5c73</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-04-26T13:55:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Tweak includes in non-moving GC headers

We don't use hash tables in non-moving GC so remove the includes.

This breaks Compact.c as existing includes no longer include Hash.h, so

include Hash.h explicitly in Compact.c.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/99823ed24b22447b14202ca57f75550773c44dbe">99823ed2</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-27T20:24:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">TH: fix Show/Eq/Ord instances for Bytes (#16457)

We shouldn't compare pointer values but the actual bytes.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c62271a21b1ba1d207aaebf370c87dd884fa6ae1">c62271a2</a></strong>

<div>

<span>by Alp Mestanogullari</span>

<i>at 2020-04-27T20:25:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: always capture both stdout and stderr when running a builder fails

The idea being that when a builder('s command) fails, we quite likely want to

have all the information available to figure out why. Depending on the builder

_and_ the particular problem, the useful bits of information can be printed

on stdout or stderr.

We accomplish this by defining a simple wrapper for Shake's `cmd` function,

that just _always_ captures both streams in case the command returns a non-zero

exit code, and by using this wrapper everywhere in `hadrian/src/Builder.hs`.

Fixes #18089.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4b9764db7c190de377c06dfc71bfe6e4b37c7eb0">4b9764db</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-04-28T15:40:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define a Quote IO instance

Fixes #18103.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/518a63d4d7e31e49a81ad66d5e5ccb1f790f6de9">518a63d4</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-04-28T15:40:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make boxed 1-tuples have known keys

Unlike other tuples, which use special syntax and are "known" by way

of a special `isBuiltInOcc_maybe` code path, boxed 1-tuples do not

use special syntax. Therefore, in order to make sure that the

internals of GHC are aware of the `data Unit a = Unit a` definition

in `GHC.Tuple`, we give `Unit` known keys. For the full details, see

`Note [One-tuples] (Wrinkle: Make boxed one-tuple names have known keys)`

in `GHC.Builtin.Types`.

Fixes #18097.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2cfc4ab9710c873a55e9a44aac9dacb06ecce36f">2cfc4ab9</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document backpack fields in DynFlags

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/10a2ba90aa6a788677104cc43318c66f46e2e2b0">10a2ba90</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor UnitInfo

* Rename InstalledPackageInfo into GenericUnitInfo

The name InstalledPackageInfo is only kept for alleged backward

compatibility reason in Cabal. ghc-boot has its own stripped down copy

of this datatype but it doesn't need to keep the name. Internally we

already use type aliases (UnitInfo in GHC, PackageCacheFormat in

ghc-pkg).

* Rename UnitInfo fields: add "unit" prefix and fix misleading names

* Add comments on every UnitInfo field

* Rename SourcePackageId into PackageId

"Package" already indicates that it's a "source package". Installed

package components are called units.

Update Haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/69562e34fb5d9571e9efc1cb90c879e50129a510">69562e34</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused `emptyGenericUnitInfo`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9e2c8e0e37a2709d5790d6c9a877a1463d6e88b5">9e2c8e0e</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor UnitInfo load/store from databases

Converting between UnitInfo stored in package databases and UnitInfo as

they are used in ghc-pkg and ghc was done in a very convoluted way (via

BinaryStringRep and DbUnitModuleRep type classes using fun deps, etc.).

It was difficult to understand and even more to modify (I wanted to

try to use a GADT for UnitId but fun deps got in the way).

The new code uses much more straightforward functions to convert between

the different representations. Much simpler.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea717aa4248b2122e1f7550f30239b50ab560e4f">ea717aa4</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Factorize mungePackagePaths code

This patch factorizes the duplicated code used in ghc-pkg and in GHC to

munge package paths/urls.

It also fixes haddock-html munging in GHC (allowed to be either a file

or a url) to mimic ghc-pkg behavior.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/10d15f1ec4bab4dd6152d87fc66e61658a705eb3">10d15f1e</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactoring unit management code

Over the years the unit management code has been modified a lot to keep

up with changes in Cabal (e.g. support for several library components in

the same package), to integrate BackPack, etc. I found it very hard to

understand as the terminology wasn't consistent, was referring to past

concepts, etc.

The terminology is now explained as clearly as I could in the Note

"About Units" and the code is refactored to reflect it.

-------------------

Many names were misleading: UnitId is not an Id but could be a virtual

unit (an indefinite one instantiated on the fly), IndefUnitId

constructor may contain a definite instantiated unit, etc.

   * Rename IndefUnitId into InstantiatedUnit

   * Rename IndefModule into InstantiatedModule

   * Rename UnitId type into Unit

   * Rename IndefiniteUnitId constructor into VirtUnit

   * Rename DefiniteUnitId constructor into RealUnit

   * Rename packageConfigId into mkUnit

   * Rename getPackageDetails into unsafeGetUnitInfo

   * Rename InstalledUnitId into UnitId

Remove references to misleading ComponentId: a ComponentId is just an

indefinite unit-id to be instantiated.

   * Rename ComponentId into IndefUnitId

   * Rename ComponentDetails into UnitPprInfo

   * Fix display of UnitPprInfo with empty version: this is now used for

     units dynamically generated by BackPack

Generalize several types (Module, Unit, etc.) so that they can be used

with different unit identifier types: UnitKey, UnitId, Unit, etc.

   * GenModule: Module, InstantiatedModule and InstalledModule are now

     instances of this type

   * Generalize DefUnitId, IndefUnitId, Unit, InstantiatedUnit,

     PackageDatabase

Replace BackPack fake "hole" UnitId by a proper HoleUnit constructor.

Add basic support for UnitKey. They should be used more in the future to

avoid mixing them up with UnitId as we do now.

Add many comments.

Update Haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8bfb0219587b969d5c8f723c46d433e9493958b4">8bfb0219</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-04-30T01:56:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Unit: split and rename modules

Introduce GHC.Unit.* hierarchy for everything concerning units, packages

and modules.

Update Haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/71484b09fa3c676e99785b3d68f69d4cfb14266e">71484b09</a></strong>

<div>

<span>by Alexis King</span>

<i>at 2020-04-30T01:57:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow block arguments in arrow control operators

Arrow control operators have their own entries in the grammar, so they

did not cooperate with BlockArguments. This was just a minor oversight,

so this patch adjusts the grammar to add the desired behavior.

fixes #18050

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a48cd2a045695c5f34ed7b00184a8d91c4fcac0e">a48cd2a0</a></strong>

<div>

<span>by Alexis King</span>

<i>at 2020-04-30T01:57:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow LambdaCase to be used as a command in proc notation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f4d3773c7f4209cd3a0495ab9a29b978da48e2ff">f4d3773c</a></strong>

<div>

<span>by Alexis King</span>

<i>at 2020-04-30T01:57:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document BlockArguments/LambdaCase support in arrow notation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5bdfdd139e5aff57631e9f1c6654dc7b8590c63f">5bdfdd13</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-04-30T01:58:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add tests for #17873

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/19b701c216246596710f0eba112ed5ee7b6bf870">19b701c2</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-04-30T07:30:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Mark rule args as non-tail-called

This was just an omission...b I'd failed to call markAllNonTailCall on

rule args.  I think this bug has been here a long time, but it's quite

hard to trigger.

Fixes #18098

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/014ef4a3d9ee30b8add9118950f1f5007143bd1c">014ef4a3</a></strong>

<div>

<span>by Matthew Pickering</span>

<i>at 2020-04-30T07:30:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: Improve tool-args command to support more components

There is a new command to hadrian, tool:path/to/file.hs, which returns

the options needed to compile that file in GHCi.

This is now used in the ghci script with argument `ghc/Main.hs` but its

main purpose is to support the new multi-component branch of ghcide.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2aa676114bca40d6124ba90d13242c7c102369e0">2aa67611</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-04-30T21:34:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Clear bitmap after initializing block size

Previously nonmovingInitSegment would clear the bitmap before

initializing the segment's block size. This is broken since

nonmovingClearBitmap looks at the segment's block size to determine how

much bitmap to clear.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/54dad3cf1e04f16ea00fb6a41b378e948c8ebf0f">54dad3cf</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-04-30T21:34:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Explicitly memoize block count

A profile cast doubt on whether the compiler hoisted the bound out the

loop as I would have expected here. It turns out it did but nevertheless

it seems clearer to just do this manually.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/99ff8145044288a8a58c8028516903937ba3935c">99ff8145</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-04-30T21:34:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Eagerly flush all capabilities' update remembered sets

(cherry picked from commit 2fa79119570b358a4db61446396889b8260d7957)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/05b0a9fd136869f71245e12fdae64d42dc2ee1df">05b0a9fd</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-04-30T21:35:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove OneShotInfo field of LFReEntrant, document OneShotInfo

The field is only used in withNewTickyCounterFun and it's easier to

directly pass a parameter for one-shot info to withNewTickyCounterFun

instead of passing it via LFReEntrant. This also makes !2842 simpler.

Other changes:

- New Note (by SPJ) [OneShotInfo overview] added.

- Arity argument of thunkCode removed as it's always 0.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a43620c621563deed76ba6b417e3a7a707c15d23">a43620c6</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-04-30T21:35:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.StgToCmm.Ticky: remove a few unused stuff

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/780de9e11014a88a4f676eb296c30fec2b07b5c2">780de9e1</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-01T10:37:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use platform in Iface Binary

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f8386c7b6a9d26bc5fd2c1d74d944c8df6337690">f8386c7b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-01T10:37:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor PprDebug handling

If `-dppr-debug` is set, then PprUser and PprDump styles are silently

replaced with PprDebug style. This was done in `mkUserStyle` and

`mkDumpStyle` smart constructors. As a consequence they needed a

DynFlags parameter.

Now we keep the original PprUser and PprDump styles until they are used

to create an `SDocContext`. I.e. the substitution is only performed in

`initSDocContext`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b3df9e780fb2f5658412c644849cd0f1e6f50331">b3df9e78</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-01T10:37:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove PprStyle param of logging actions

Use `withPprStyle` instead to apply a specific style to a SDoc.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/de9fc995c2170bc34600ee3fc80393c67cfecad1">de9fc995</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-01T10:37:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fully remove PprDebug

PprDebug was a pain to deal with consistently as it is implied by

`-dppr-debug` but it isn't really a PprStyle. We remove it completely

and query the appropriate SDoc flag instead (`sdocPprDebug`) via

helpers (`getPprDebug` and its friends).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8b51fcbd67ca17a6dcc2f9e5a29176f836bf11d2">8b51fcbd</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-01T10:38:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Only call checkSingle if we would report warnings

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/fd7ea0fee92a60f9658254cc4fe3abdb4ff299b1">fd7ea0fe</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-01T10:38:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Pick up `EvVar`s bound in `HsWrapper`s for long-distance info

`HsWrapper`s introduce evidence bindings through `WpEvLam` which the

pattern-match coverage checker should be made aware of.

Failing to do so caused #18049, where the resulting impreciseness of

imcompleteness warnings seemingly contradicted with

`-Winaccessible-code`.

The solution is simple: Collect all the evidence binders of an

`HsWrapper` and add it to the ambient `Deltas` before desugaring

the wrapped expression.

But that means we pick up many more evidence bindings, even when they

wrap around code without a single pattern match to check! That regressed

`T3064` by over 300%, so now we are adding long-distance info lazily

through judicious use of `unsafeInterleaveIO`.

Fixes #18049.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7bfe9ac514e18c0b0e24ff55230fe98ec9db894c">7bfe9ac5</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-03T04:41:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Enable tracing of nonmoving heap census with -ln

Previously this was not easily available to the user. Fix this.

Non-moving collection lifecycle events are now reported with -lg.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c560dd07f506810eaabae2f582491138aa224819">c560dd07</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-03T04:41:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users guide: Move eventlog documentation users guide

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/02543d5ef9bd7a910fc9fece895780583ab9635a">02543d5e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-03T04:41:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users guide: Add documentation for non-moving GC events

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b465dd4500beffe919e8b8dcd075008399fbf446">b465dd45</a></strong>

<div>

<span>by Alexis King</span>

<i>at 2020-05-03T04:42:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Flatten nested casts in the simple optimizer

Normally, we aren’t supposed to generated any nested casts, since mkCast

takes care to flatten them, but the simple optimizer didn’t use mkCast,

so they could show up after inlining. This isn’t really a problem, since

the simplifier will clean them up immediately anyway, but it can clutter

the -ddump-ds output, and it’s an extremely easy fix.

closes #18112

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8bdc03d61cb7a2f96887c86bd0b253f7c108fcde">8bdc03d6</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-04T01:56:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't return a panic in tcNestedSplice

In GHC.Tc.Gen.Splice.tcNestedSplice we were returning a

typechecked expression of "panic". That is usually OK, because

the result is discarded.  But it happens that tcApp now looks at

the typechecked expression, trivially, to ask if it is tagToEnum.

So being bottom is bad.

Moreover a debug-trace might print it out.

So better to return a civilised expression, even though it is

usually discarded.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0bf640b19d7a7ad0800152752a71c1dd4e6c696d">0bf640b1</a></strong>

<div>

<span>by Baldur Blöndal</span>

<i>at 2020-05-04T01:57:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't require parentheses around via type (`-XDerivingVia'). Fixes #18130".

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/30272412fa437ab8e7a8035db94a278e10513413">30272412</a></strong>

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-05-04T13:19:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove custom ExceptionMonad class (#18075) (updating haddock submodule accordingly)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b9f7c08ff5aa71b7673c8136b897e6f29de01330">b9f7c08f</a></strong>

<div>

<span>by jneira</span>

<i>at 2020-05-04T13:20:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused hs-boot file

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1d8f80cd64edd1ea6a5d4c4aa2e09ad0d077ae1b">1d8f80cd</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-05T03:22:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove references to -package-key

* remove references to `-package-key` which has been removed in 2016

  (240ddd7c39536776e955e881d709bbb039b48513)

* remove support for `-this-package-key` which has been deprecated at the

  same time

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7bc3a65b467c4286377b9bded277d5a2f69160b3">7bc3a65b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-05T03:23:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove SpecConstrAnnotation (#13681)

This has been deprecated since 2013. Use GHC.Types.SPEC instead.

Make GHC.Exts "not-home" for haddock

Metric Decrease:

   haddock.base

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3c862f635394b02c121f917a4d9ea7802033eebb">3c862f63</a></strong>

<div>

<span>by DenisFrezzato</span>

<i>at 2020-05-05T03:24:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix Haskell98 short description in documentation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2420c555e6cb681f4ef7c4ae3192a850ab431759">2420c555</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-05T03:24:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add regression tests for #16244, #16245, #16758

Commit e3c374cc5bd7eb49649b9f507f9f7740697e3f70 ended up

fixing quite a few bugs:

* This commit fixes #16244 completely. A regression test has been

  added.

* This commit fixes one program from #16245. (The program in

  https://gitlab.haskell.org/ghc/ghc/issues/16245#note_211369 still

  panics, and the program in

  https://gitlab.haskell.org/ghc/ghc/issues/16245#note_211400 still

  loops infinitely.) A regression test has been added for this

  program.

* This commit fixes #16758. Accordingly, this patch removes the

  `expect_broken` label from the `T16758` test case, moves it from

  `should_compile` to `should_fail` (as it should produce an error

  message), and checks in the expected stderr.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/40c71c2cf38b4e134d81b7184a4d5e02949ae70c">40c71c2c</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-05T03:25:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix colorized error messages (#18128)

In b3df9e780fb2f5658412c644849cd0f1e6f50331 I broke colorized messages

by using "dump" style instead of "user" style. This commits fixes it.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7ab6ab093c86227b6d33a5185ebbd11928ac9754">7ab6ab09</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-05-06T04:39:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor hole constraints.

Previously, holes (both expression holes / out of scope variables and

partial-type-signature wildcards) were emitted as *constraints* via

the CHoleCan constructor. While this worked fine for error reporting,

there was a fair amount of faff in keeping these constraints in line.

In particular, and unlike other constraints, we could never change

a CHoleCan to become CNonCanonical. In addition:

 * the "predicate" of a CHoleCan constraint was really the type

   of the hole, which is not a predicate at all

 * type-level holes (partial type signature wildcards) carried

   evidence, which was never used

 * tcNormalise (used in the pattern-match checker) had to create

   a hole constraint just to extract it again; it was quite messy

The new approach is to record holes directly in WantedConstraints.

It flows much more nicely now.

Along the way, I did some cleaning up of commentary in

GHC.Tc.Errors.Hole, which I had a hard time understanding.

This was instigated by a future patch that will refactor

the way predicates are handled. The fact that CHoleCan's

"predicate" wasn't really a predicate is incompatible with

that future patch.

No test case, because this is meant to be purely internal.

It turns out that this change improves the performance of

the pattern-match checker, likely because fewer constraints

are sloshing about in tcNormalise. I have not investigated

deeply, but an improvement is not a surprise here:

-------------------------

Metric Decrease:

    PmSeriesG

-------------------------

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/420b957df9d831632a3edab682778b11734255f1">420b957d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-06T04:40:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Zero block flags with -DZ

Block flags are very useful for determining the state of a block.

However, some block allocator users don't touch them, leading to

misleading values. Ensure that we zero then when zero-on-gc is set. This

is safe and makes the flags more useful during debugging.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/740b3b8df76dabd88bdb3474aad2b287b0960f07">740b3b8d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-06T04:40:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Fix incorrect failed_to_evac value during deadlock gc

Previously we would incorrectly set the failed_to_evac flag if we

evacuated a value due to a deadlock GC. This would cause us to mark more

things as dirty than strictly necessary. It also turned up a nasty but

which I will fix next.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b2d72c758233830446230800d0045badc01b42ca">b2d72c75</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-06T04:40:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Fix handling of dirty objects

Previously we (incorrectly) relied on failed_to_evac to be "precise".

That is, we expected it to only be true if *all* of an object's fields

lived outside of the non-moving heap. However, does not match the

behavior of failed_to_evac, which is true if *any* of the object's

fields weren't promoted (meaning that some others *may* live in the

non-moving heap).

This is problematic as we skip the non-moving write barrier for dirty

objects (which we can only safely do if *all* fields point outside of

the non-moving heap).

Clearly this arises due to a fundamental difference in the behavior

expected of failed_to_evac in the moving and non-moving collector.

e.g., in the moving collector it is always safe to conservatively say

failed_to_evac=true whereas in the non-moving collector the safe value

is false.

This issue went unnoticed as I never wrote down the dirtiness

invariant enforced by the non-moving collector. We now define this

invariant as

    An object being marked as dirty implies that all of its fields are

    on the mark queue (or, equivalently, update remembered set).

To maintain this invariant we teach nonmovingScavengeOne to push the

fields of objects which we fail to evacuate to the update remembered

set. This is a simple and reasonably cheap solution and avoids the

complexity and fragility that other, more strict alternative invariants

would require.

All of this is described in a new Note, Note [Dirty flags in the

non-moving collector] in NonMoving.c.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9f3e6884e338015f2953c4c0844e04d467f53dd5">9f3e6884</a></strong>

<div>

<span>by Zubin Duggal</span>

<i>at 2020-05-06T04:41:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow atomic update of NameCache in readHieFile

The situation arises in ghcide where multiple different threads may need to

update the name cache, therefore with the older interface it could happen

that you start reading a hie file with name cache A and produce name cache

A + B, but another thread in the meantime updated the namecache to A +

C. Therefore if you write the new namecache you will lose the A' updates

from the second thread.

Updates haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/edec6a6c205378caf15d1d874d7e901ba76dd293">edec6a6c</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-06T04:41:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make isTauTy detect higher-rank contexts

Previously, `isTauTy` would only detect higher-rank `forall`s, not

higher-rank contexts, which led to some minor bugs observed

in #18127. Easily fixed by adding a case for

`(FunTy InvisArg _ _)`.

Fixes #18127.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a95e7fe02efd2fdeec91ba46de64bc78c81381eb">a95e7fe0</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-05-06T04:42:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ELF linker: increment curSymbol after filling in fields of current entry

The bug was introduced in a8b7cef4d45 which added a field to the

`symbols` array elements and then updated this code incorrectly:

    - oc->symbols[curSymbol++] = nm;

    + oc->symbols[curSymbol++].name = nm;

    + oc->symbols[curSymbol].addr = symbol->addr;

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cab1871ab93feeacf2bf9a1c65b1c919ca9c5399">cab1871a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-06T04:43:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move LeadingUnderscore into Platform (#17957)

Avoid direct use of DynFlags to know if symbols must be prefixed by an

underscore.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/94e7c563ab24fe452a16900a6777349970df1945">94e7c563</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-06T04:43:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't use DynFlags in showLinkerState (#17957)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9afd92512b41cf6c6de3a17b474d8d4bb01158c3">9afd9251</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-06T04:43:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactoring: Use bindSigTyVarsFV in rnMethodBinds

`rnMethodBinds` was explicitly using `xoptM` to determine if

`ScopedTypeVariables` is enabled before bringing type variables

bound by the class/instance header into scope. However, this `xoptM`

logic is already performed by the `bindSigTyVarsFV` function. This

patch uses `bindSigTyVarsFV` in `rnMethodBinds` to reduce the number

of places where we need to consult if `ScopedTypeVariables` is on.

This is purely refactoring, and there should be no user-visible

change in behavior.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6f6d72b2c382860a5f7a08779b2405da8473814c">6f6d72b2</a></strong>

<div>

<span>by Brian Foley</span>

<i>at 2020-05-08T15:29:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove further dead code found by a simple Python script.

Avoid removing some functions that are part of an API even

though they're not used in-tree at the moment.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/78bf8bf967551f8667b766328504cfbd24df9bfb">78bf8bf9</a></strong>

<div>

<span>by Julien Debon</span>

<i>at 2020-05-08T15:29:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add doc examples for Bifoldable

See #17929

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/66f0a847255f15ec656a37d639556b7918f6aac2">66f0a847</a></strong>

<div>

<span>by Julien Debon</span>

<i>at 2020-05-08T15:29:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">doc (Bitraversable): Add examples to Bitraversable

* Add examples to Data.Bitraversable

* Fix formatting for (,) in Bitraversable and Bifoldable

* Fix mistake on bimapAccumR documentation

See #17929

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9749fe1223d182b1f8e7e4f7378df661c509f396">9749fe12</a></strong>

<div>

<span>by Baldur Blöndal</span>

<i>at 2020-05-08T15:29:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Specify kind variables for inferred kinds in base.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4e9aef9ea732e8157ee0b7fbb85b2cdfbf49de5f">4e9aef9e</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-08T15:29:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">HsSigWcTypeScoping: Pull in documentation from stray location

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f4d5c6df56a28be5448acf43e4f45b1695ae9eb5">f4d5c6df</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-08T15:29:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename local `real_fvs` to `implicit_vs`

It doesn't make sense to call the "free" variables we are about to

implicitly bind the real ones.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/20570b4b5e741912d1dc3f1826ee1f78e33f3b90">20570b4b</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-08T15:29:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">A few tiny style nits with renaming

 - Use case rather than guards that repeatedly scrutenize same thing.

 - No need for view pattern when `L` is fine.

 - Use type synnonym to convey the intent like elsewhere.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/09ac8de5777d5ca953279a6c0ee42a6fba0fcba6">09ac8de5</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-08T15:29:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add `forAllOrNothing` function with note

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/bb35c0e573b0bc8fe6a28c00734fa124da02a755">bb35c0e5</a></strong>

<div>

<span>by Joseph C. Sible</span>

<i>at 2020-05-08T15:29:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document lawlessness of Ap's Num instance</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cdd229fff24ab19a41dd2af218108dd8c514fff7">cdd229ff</a></strong>

<div>

<span>by Joseph C. Sible</span>

<i>at 2020-05-08T15:29:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to libraries/base/Data/Monoid.hs</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/926d2aab83dc6068cba76f71a19b040eddc6dee9">926d2aab</a></strong>

<div>

<span>by Joseph C. Sible</span>

<i>at 2020-05-08T15:29:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply more suggestions from Simon Jakobi</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7a763cff78d2d4b23d05554e68138678cb4ba627">7a763cff</a></strong>

<div>

<span>by Adam Gundry</span>

<i>at 2020-05-08T15:29:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reject all duplicate declarations involving DuplicateRecordFields (fixes #17965)

This fixes a bug that resulted in some programs being accepted that used the same

identifier as a field label and another declaration, depending on the order they

appeared in the source code.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/88e3c8150d2b2d96c3ebc0b2942c9af44071c511">88e3c815</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-08T15:29:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix specialisation for DFuns

When specialising a DFun we must take care to saturate the

unfolding.  See Note [Specialising DFuns] in Specialise.

Fixes #18120

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/86c77b36628dcce7bc9b066fc24c8c521fecc3ee">86c77b36</a></strong>

<div>

<span>by Greg Steuck</span>

<i>at 2020-05-08T15:29:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused SEGMENT_PROT_RWX

It's been unused for a year and is problematic on any OS which

requires W^X for security.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9d97f4b5ddcfdf32b52734188f595d9a11fd4879">9d97f4b5</a></strong>

<div>

<span>by nineonine</span>

<i>at 2020-05-08T15:30:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add test for #16167

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/aa318338b753ab6e9db44cf2c2d285827eb35a03">aa318338</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-08T15:30:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump exceptions submodule so that dist-boot is .gitignore'd

`exceptions` is a stage-0 boot library as of commit

30272412fa437ab8e7a8035db94a278e10513413, which means that building

`exceptions` in a GHC tree will generate a `dist-boot` directory.

However, this directory was not specified in `exceptions`'

`.gitignore` file, which causes it to dirty up the current `git`

working directory.

Accordingly, this bumps the `exceptions` submodule to commit

ghc/packages/exceptions@23c0b8a50d7592af37ca09beeec16b93080df98f,

which adds `dist-boot` to the `.gitignore` file.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/ea86360f21e8c9812acba8dc1bc2a54fef700ece">ea86360f</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-05-08T15:30:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linker.c: initialize n_symbols of ObjectCode with other fields

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/951c1fb03d80094c8b0d9bcc463d86fa71695b3a">951c1fb0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-09T21:46:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix unboxed-sums GC ptr-slot rubbish value (#17791)

This patch allows boot libraries to use unboxed sums without implicitly

depending on `base` package because of `absentSumFieldError`.

See updated Note [aBSENT_SUM_FIELD_ERROR_ID] in GHC.Core.Make

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b352d63cbbfbee69358c198edd876fe7ef9d63ef">b352d63c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-09T21:47:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Make non-existent linker search path merely a warning

As noted in #18105, previously this resulted in a rather intrusive error

message. This is in contrast to the general expectation that search

paths are merely places to look, not places that must exist.

Fixes #18105.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cf4f1e2f78840d25b132de55bce1e02256334ace">cf4f1e2f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:02:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/CNF: Fix fixup comparison function

Previously we would implicitly convert the difference between two words

to an int, resulting in an integer overflow on 64-bit machines.

Fixes #16992

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a03da9bfcf130bec616e0f77bbefbf62022753de">a03da9bf</a></strong>

<div>

<span>by Ömer Sinan Ağacan</span>

<i>at 2020-05-13T02:03:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pack some of IdInfo fields into a bit field

This reduces residency of compiler quite a bit on some programs.

Example stats when building T10370:

Before:

   2,871,242,832 bytes allocated in the heap

   4,693,328,008 bytes copied during GC

      33,941,448 bytes maximum residency (276 sample(s))

         375,976 bytes maximum slop

              83 MiB total memory in use (0 MB lost due to fragmentation)

After:

   2,858,897,344 bytes allocated in the heap

   4,629,255,440 bytes copied during GC

      32,616,624 bytes maximum residency (278 sample(s))

         314,400 bytes maximum slop

              80 MiB total memory in use (0 MB lost due to fragmentation)

So -3.9% residency, -1.3% bytes copied and -0.4% allocations.

Fixes #17497

Metric Decrease:

    T9233

    T9675

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/670c3e5c84c5b638dc6277289db3cbbc39a03c36">670c3e5c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:03:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">get-win32-tarballs: Fix base URL

Revert a change previously made for testing purposes.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8ad8dc412f0b070df63e42e68468df08ac0f559a">8ad8dc41</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:03:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">get-win32-tarballs: Improve diagnostics output

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8c0740b7c38184378aedefdca8fff35707c80de9">8c0740b7</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-05-13T02:04:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: Add examples for Data.Semigroup.Arg{Min,Max}

Context: #17153

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cb22348fb92411c66f1a39fe2c34b167a9926bc7">cb22348f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:05:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add few cleanups of the CAF logic

Give the NameSet of non-CAFfy names a proper newtype to distinguish it

from all of the other NameSets floating about.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/90e38b8139c10854280da56664c040120256bacc">90e38b81</a></strong>

<div>

<span>by Emeka Nkurumeh</span>

<i>at 2020-05-13T02:05:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix printf warning when using with ghc with clang on mingw</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/86d8ac22608eb8f04ceaff65e76dbeec23b76753">86d8ac22</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-13T02:06:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CprAnal: Don't attach CPR sigs to expandable bindings (#18154)

Instead, look through expandable unfoldings in `cprTransform`.

See the new Note [CPR for expandable unfoldings]:

```

Long static data structures (whether top-level or not) like

  xs = x1 : xs1

  xs1 = x2 : xs2

  xs2 = x3 : xs3

should not get CPR signatures, because they

  * Never get WW'd, so their CPR signature should be irrelevant after analysis

    (in fact the signature might even be harmful for that reason)

  * Would need to be inlined/expanded to see their constructed product

  * Recording CPR on them blows up interface file sizes and is redundant with

    their unfolding. In case of Nested CPR, this blow-up can be quadratic!

But we can't just stop giving DataCon application bindings the CPR property,

for example

  fac 0 = 1

  fac n = n * fac (n-1)

fac certainly has the CPR property and should be WW'd! But FloatOut will

transform the first clause to

  lvl = 1

  fac 0 = lvl

If lvl doesn't have the CPR property, fac won't either. But lvl doesn't have a

CPR signature to extrapolate into a CPR transformer ('cprTransform'). So

instead we keep on cprAnal'ing through *expandable* unfoldings for these arity

0 bindings via 'cprExpandUnfolding_maybe'.

In practice, GHC generates a lot of (nested) TyCon and KindRep bindings, one

for each data declaration. It's wasteful to attach CPR signatures to each of

them (and intractable in case of Nested CPR).

```

Fixes #18154.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e34bf65613f0062ea902fb3d59623701b7cd01d5">e34bf656</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:07:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Add discussion of shared object naming

Fixes #18074.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5d0f244528f8f7ba3058a4cf7b075a474c63fa1b">5d0f2445</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:07:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Print sign of performance changes

Executes the minor formatting change in the tabulated performance

changes suggested in #18135.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9e4b981ff7a0852c7bdc93039eed13582d923241">9e4b981f</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T02:08:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add testcase for #18129

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/266310c300f2254dfdeb5eb2123737f765ed18f8">266310c3</a></strong>

<div>

<span>by Ivan-Yudin</span>

<i>at 2020-05-13T02:09:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">doc: Reformulate the opening paragraph of Ch. 4 in User's guide

Removes mentioning of Hugs

(it is not helpful for new users anymore).

Changes the wording for the rest of the paragraph.

Fixes #18132.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/55e35c0b7e0f4b907dc21d42827b1cea4317226e">55e35c0b</a></strong>

<div>

<span>by Baldur Blöndal</span>

<i>at 2020-05-13T20:02:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Predicate, Equivalence derive via `.. -> a -> All'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d7e0b57fda289e2715e7be86d4871503e3c09ee8">d7e0b57f</a></strong>

<div>

<span>by Alp Mestanogullari</span>

<i>at 2020-05-13T20:03:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: add a --freeze2 option to freeze stage 1 and 2

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d880d6b2e48268f5ed4d3eb751fe24cc833e9221">d880d6b2</a></strong>

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-05-13T20:04:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't reload environment files on every setSessionDynFlags

Makes `interpretPackageEnv` (which loads envirinment files) a part of

`parseDynamicFlags` (parsing command-line arguments, which is typically

done once) instead of `setSessionDynFlags` (which is typically called

several times). Making several (transitive) calls to `interpretPackageEnv`,

as before, caused #18125 #16318, which should be fixed now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/102cfd6784d16a0d0cc8bdf42d4de4c7b8dd0190">102cfd67</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-13T20:04:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Factor out HsPatSigType for pat sigs/RULE term sigs (#16762)

This implements chunks (2) and (3) of

https://gitlab.haskell.org/ghc/ghc/issues/16762#note_270170. Namely,

it introduces a dedicated `HsPatSigType` AST type, which represents

the types that can appear in pattern signatures and term-level `RULE`

binders. Previously, these were represented with `LHsSigWcType`.

Although `LHsSigWcType` is isomorphic to `HsPatSigType`, the intended

semantics of the two types are slightly different, as evidenced by

the fact that they have different code paths in the renamer and

typechecker.

See also the new `Note [Pattern signature binders and scoping]` in

`GHC.Hs.Types`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b17574f74173d0fa83b0def070dcba51b710be2e">b17574f7</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-05-13T20:05:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix(documentation): Fix the RST links to GHC.Prim

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/df021fb15bcef313f30e772997bcb263c8f34078">df021fb1</a></strong>

<div>

<span>by Baldur Blöndal</span>

<i>at 2020-05-13T20:06:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document (->) using inferred quantification for its runtime representations.

Fixes #18142.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1a93ea57355d521b92daf4e3120de88a1f94deee">1a93ea57</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-05-13T20:06:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Tweak man page for ghc command

This commit updates the ghc command's man page as followings:

* Enable `man_show_urls` to show URL addresses in the `DESCRIPTION`

section of ghc.rst, because sphinx currently removes hyperlinks

for man pages.

* Add a `SEE ALSO` section to point to the GHC homepage

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a951e1bab3dfd3e9de31b0d8bf5699a9216b181d">a951e1ba</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-05-13T20:07:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHCi: Add link to the user's guide in help message

This commit adds a link to the user's guide in ghci's

`:help` message.

Newcomers could easily reach to details of ghci.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/404581eaa3bf8d3f100da7610a6a38158bea17c4">404581ea</a></strong>

<div>

<span>by Jeff Happily</span>

<i>at 2020-05-13T20:08:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Handle single unused import

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1c999e5d4e63e7b407b174f51913cfa38e2dec46">1c999e5d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T20:09:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Ensure that printMinimalImports closes handle

Fixes #18166.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c9f5a8f4653c4696a1fbb768bd0d8f672d4c7d5f">c9f5a8f4</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-13T20:09:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Tell testsuite driver about LLVM availability

This reflects the logic present in the Make build system into Hadrian.

Fixes #18167.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c05c06596bd1b2852454af6243fc15ee852d2f45">c05c0659</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-05-14T03:31:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve some folds over Uniq[D]FM

* Replace some non-deterministic lazy folds with

  strict folds.

* Replace some O(n log n) folds in deterministic order

  with O(n) non-deterministic folds.

* Replace some folds with set-operations on the underlying

  IntMaps.

This reduces max residency when compiling

`nofib/spectral/simple/Main.hs` with -O0 by about 1%.

Maximum residency when compiling Cabal also seems reduced on the

order of 3-9%.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/477f13bb4c5c2ba969d2c90890c51d7de01c5312">477f13bb</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-05-14T03:31:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use Data.IntMap.disjoint

Data.IntMap gained a dedicated `disjoint` function in containers-0.6.2.1.

This patch applies this function where appropriate in hopes of modest

compiler performance improvements.

Closes #16806.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e9c0110ce9e753360d7e6523114109b7616f2f08">e9c0110c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-14T12:25:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">IdInfo: Add reference to bitfield-packing ticket

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9bd20e83ff9b65bd5496fbb29d27072c9e4e84b9">9bd20e83</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-15T10:42:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DmdAnal: Improve handling of precise exceptions

This patch does two things: Fix possible unsoundness in what was called

the "IO hack" and implement part 2.1 of the "fixing precise exceptions"

plan in

https://gitlab.haskell.org/ghc/ghc/wikis/fixing-precise-exceptions,

which, in combination with !2956, supersedes !3014 and !2525.

**IO hack**

The "IO hack" (which is a fallback to preserve precise exceptions

semantics and thus soundness, rather than some smart thing that

increases precision) is called `exprMayThrowPreciseException` now.

I came up with two testcases exemplifying possible unsoundness (if

twisted enough) in the old approach:

- `T13380d`: Demonstrating unsoundness of the "IO hack" when resorting

             to manual state token threading and direct use of primops.

             More details below.

- `T13380e`: Demonstrating unsoundness of the "IO hack" when we have

             Nested CPR. Not currently relevant, as we don't have Nested

             CPR yet.

- `T13380f`: Demonstrating unsoundness of the "IO hack" for safe FFI

             calls.

Basically, the IO hack assumed that precise exceptions can only be

thrown from a case scrutinee of type `(# State# RealWorld, _ #)`. I

couldn't come up with a program using the `IO` abstraction that violates

this assumption. But it's easy to do so via manual state token threading

and direct use of primops, see `T13380d`. Also similar code might be

generated by Nested CPR in the (hopefully not too) distant future, see

`T13380e`. Hence, we now have a more careful test in `forcesRealWorld`

that passes `T13380{d,e}` (and will hopefully be robust to Nested CPR).

**Precise exceptions**

In #13380 and #17676 we saw that we didn't preserve precise exception

semantics in demand analysis. We fixed that with minimal changes in

!2956, but that was terribly unprincipled.

That unprincipledness resulted in a loss of precision, which is tracked

by these new test cases:

- `T13380b`: Regression in dead code elimination, because !2956 was too

             syntactic about `raiseIO#`

- `T13380c`: No need to apply the "IO hack" when the IO action may not

             throw a precise exception (and the existing IO hack doesn't

             detect that)

Fixing both issues in !3014 turned out to be too complicated and had

the potential to regress in the future. Hence we decided to only fix

`T13380b` and augment the `Divergence` lattice with a new middle-layer

element, `ExnOrDiv`, which means either `Diverges` (, throws an

imprecise exception) or throws a *precise* exception.

See the wiki page on Step 2.1 for more implementational details:

https://gitlab.haskell.org/ghc/ghc/wikis/fixing-precise-exceptions#dead-code-elimination-for-raiseio-with-isdeadenddiv-introducing-exnordiv-step-21

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/568d7279a80cf945271f0659f11a94eea3f1433d">568d7279</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-15T10:42:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.Cmm.Opt: Handle MO_XX_Conv

This MachOp was introduced by 2c959a1894311e59cd2fd469c1967491c1e488f3

but a wildcard match in cmmMachOpFoldM hid the fact that it wasn't

handled. Ideally we would eliminate the match but this appears to be a

larger task.

Fixes #18141.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5bcf86063c0e5b6ee0d162ea64c88fdaad89e620">5bcf8606</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-05-17T08:46:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove duplicate Note [When to print foralls] in GHC.Core.TyCo.Ppr

There are two different Notes named `[When to print foralls]`. The

most up-to-date one is in `GHC.Iface.Type`, but there is a second

one in `GHC.Core.TyCo.Ppr`. The latter is less up-to-date, as it was

written before GHC switched over to using ifaces to pretty-print

types. I decided to just remove the latter and replace it with a

reference to the former.

[ci skip]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/55f0e783d234af103cf4e1d51cd31c99961c5abe">55f0e783</a></strong>

<div>

<span>by Fumiaki Kinoshita</span>

<i>at 2020-05-21T12:10:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Add Generic instances to various datatypes under GHC.*

* GHC.Fingerprint.Types: Fingerprint

* GHC.RTS.Flags: GiveGCStats, GCFlags, ConcFlags, DebugFlags, CCFlags, DoHeapProfile, ProfFlags, DoTrace, TraceFlags, TickyFlags, ParFlags and RTSFlags

* GHC.Stats: RTSStats and GCStats

* GHC.ByteOrder: ByteOrder

* GHC.Unicode: GeneralCategory

* GHC.Stack.Types: SrcLoc

Metric Increase:

    haddock.base

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a9311cd53d33439e8fe79967ba5fb85bcd114fec">a9311cd5</a></strong>

<div>

<span>by Gert-Jan Bottu</span>

<i>at 2020-05-21T12:11:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Explicit Specificity

Implementation for Ticket #16393.

Explicit specificity allows users to manually create inferred type variables,

by marking them with braces.

This way, the user determines which variables can be instantiated through

visible type application.

The additional syntax is included in the parser, allowing users to write

braces in type variable binders (type signatures, data constructors etc).

This information is passed along through the renamer and verified in the

type checker.

The AST for type variable binders, data constructors, pattern synonyms,

partial signatures and Template Haskell has been updated to include the

specificity of type variables.

Minor notes:

- Bumps haddock submodule

- Disables pattern match checking in GHC.Iface.Type with GHC 8.8

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/24e61aad37355fa3a5503b11a60ab7b314a3f405">24e61aad</a></strong>

<div>

<span>by Ben Price</span>

<i>at 2020-05-21T12:12:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Lint should say when it is checking a rule

It is rather confusing that when lint finds an error in a rule attached

to a binder, it reports the error as in the RHS, not the rule:

  ...

  In the RHS of foo

We add a clarifying line:

  ...

  In the RHS of foo

  In a rule attached to foo

The implication that the rule lives inside the RHS is a bit odd, but

this niggle is already present for unfoldings, whose pattern we are

following.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/78c6523c5106fc56b653fc14fda5741913da8fdc">78c6523c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-21T12:13:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nonmoving: Optimise the write barrier

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/13f6c9d0376214b22d4cd16bd3a8cd7b8d864990">13f6c9d0</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-05-21T12:13:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor linear reg alloc to remember past assignments.

When assigning registers we now first try registers we

assigned to in the past, instead of picking the "first"

one.

This is in extremely helpful when dealing with loops for

which variables are dead for part of the loop.

This is important for patterns like this:

        foo = arg1

    loop:

        use(foo)

        ...

        foo = getVal()

        goto loop;

There we:

* assign foo to the register of arg1.

* use foo, it's dead after this use as it's overwritten after.

* do other things.

* look for a register to put foo in.

If we pick an arbitrary one it might differ from the register the

start of the loop expect's foo to be in.

To fix this we simply look for past register assignments for

the given variable. If we find one and the register is free we

use that register.

This reduces the need for fixup blocks which match the register

assignment between blocks. In the example above between the end

and the head of the loop.

This patch also moves branch weight estimation ahead of register

allocation and adds a flag to control it (cmm-static-pred).

* It means the linear allocator is more likely to assign the hotter

  code paths first.

* If it assign these first we are:

  + Less likely to spill on the hot path.

  + Less likely to introduce fixup blocks on the hot path.

These two measure combined are surprisingly effective. Based on nofib

we get in the mean:

* -0.9% instructions executed

* -0.1% reads/writes

* -0.2% code size.

* -0.1% compiler allocations.

* -0.9% compile time.

* -0.8% runtime.

Most of the benefits are simply a result of removing redundant moves

and spills.

Reduced compiler allocations likely are the result of less code being

generated. (The added lookup is mostly non-allocating).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/edc2cc588add3f23b3650f15d3f495943f2c06f9">edc2cc58</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-05-21T12:14:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCG: Codelayout: Distinguish conditional and other branches.

In #18053 we ended up with a suboptimal code layout because

the code layout algorithm didn't distinguish between conditional

and unconditional control flow.

We can completely eliminate unconditional control flow instructions

by placing blocks next to each other, not so much for conditionals.

In terms of implementation we simply give conditional branches less

weight before computing the layout.

Fixes #18053

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b7a6b2f4c690a9711339462114a538a85dcb7d83">b7a6b2f4</a></strong>

<div>

<span>by Gleb Popov</span>

<i>at 2020-05-21T12:15:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Set locale to C.UTF-8.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a8c27cf6eef51adfa6ac9931d4f620645dc24dd3">a8c27cf6</a></strong>

<div>

<span>by Stefan Holdermans</span>

<i>at 2020-05-21T12:16:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow spaces in GHCi :script file names

This patch updates the user interface of GHCi so that file names passed

to the ':script' command may contain spaces escaped with a backslash.

For example:

  :script foo\ bar.script

The implementation uses a modified version of 'words' that does not

break on escaped spaces.

Fixes #18027.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/82663959d2f1ddbb514a652593bc8064fd69d6aa">82663959</a></strong>

<div>

<span>by Stefan Holdermans</span>

<i>at 2020-05-21T12:16:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add extra tests for GHCi :script syntax checks

The syntax for GHCi's ":script" command allows for only a single file

name to be passed as an argument. This patch adds a test for the cases

in which a file name is missing or multiple file names are passed.

Related to #T18027.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a0b79e1b16887371d5cd14d53a607772ca730fb5">a0b79e1b</a></strong>

<div>

<span>by Stefan Holdermans</span>

<i>at 2020-05-21T12:16:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow GHCi :script file names in double quotes

This patch updates the user interface of GHCi so that file names passed

to the ':script' command can be wrapped in double quotes.

For example:

  :script "foo bar.script"

The implementation uses a modified version of 'words' that treats

character sequences enclosed in double quotes as single words.

Fixes #18027.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cf5663300c3d8b8b3c7dc2cd0dce2c923ec68987">cf566330</a></strong>

<div>

<span>by Stefan Holdermans</span>

<i>at 2020-05-21T12:16:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update documentation for GHCi :script

This patch adds the fixes that allow for file names containing spaces to

be passed to GHCi's ':script' command to the release notes for 8.12 and

expands the user-guide documentation for ':script' by mentioning how

such file names can be passed.

Related to #18027.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0004ccb885e534c386ceae21580fc59ec7ad0ede">0004ccb8</a></strong>

<div>

<span>by Tuan Le</span>

<i>at 2020-05-21T12:16:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">llvmGen: Consider Relocatable read-only data as not constantReferences: #18137

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/964d3ea21e734a4b2ad3ab97955274a003242121">964d3ea2</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use `Checker` for `tc_pat`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b797aa420b65c8ee214a4fc94813d0d597352bb4">b797aa42</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use `Checker` for `tc_lpat` and `tc_lpats`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5108e84abb102920ab28e3aeb083ab6e483eb2f6">5108e84a</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">More judiciously panic in `ts_pat`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/510e04515bb3eaed95d374d685b5322ad7e6389d">510e0451</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Put `PatEnv` first in `GHC.Tc.Gen.Pat.Checker`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cb4231db322f4a2bb146c456852df6cdf1498dca">cb4231db</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Tiny cleaup eta-reduce away a function argument

In GHC, not in the code being compiled!

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6890c38d4568ca444cccc47dd1a86c5e020c3521">6890c38d</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-21T12:17:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use braces with do in `SplicePat` case for consistency

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3451584f98d4a6b26dba4079b9a703e70a49a3ab">3451584f</a></strong>

<div>

<span>by buggymcbugfix</span>

<i>at 2020-05-21T12:18:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix spelling mistakes and typos

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b552e53136abfd6d728563338df99bf899d16139">b552e531</a></strong>

<div>

<span>by buggymcbugfix</span>

<i>at 2020-05-21T12:18:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add INLINABLE pragmas to Enum list producers

The INLINABLE pragmas ensure that we export stable (unoptimised) unfoldings in

the interface file so we can do list fusion at usage sites.

Related tickets: #15185, #8763, #18178.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e748006355d85fcddd17ba206873b0051219abb1">e7480063</a></strong>

<div>

<span>by buggymcbugfix</span>

<i>at 2020-05-21T12:18:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Piggyback on Enum Word methods for Word64

If we are on a 64 bit platform, we can use the efficient Enum Word

methods for the Enum Word64 instance.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/892b0c41816fca4eeea42ca03a43aac473311837">892b0c41</a></strong>

<div>

<span>by buggymcbugfix</span>

<i>at 2020-05-21T12:18:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document INLINE(ABLE) pragmas that enable fusion

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2b363ebb988cbf8c92df24eef5366293a80ecb19">2b363ebb</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-05-21T12:18:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">MR template should ask for key part</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a95bbd0bdf06d7d61b0bef6de77b59ca31b2c32d">a95bbd0b</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-21T12:19:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make `Int`'s `mod` and `rem` strict in their first arguments

They used to be strict until 4d2ac2d (9 years ago).

It's obviously better to be strict for performance reasons.

It also blocks #18067.

NoFib results:

```

--------------------------------------------------------------------------------

        Program         Allocs    Instrs

--------------------------------------------------------------------------------

        integer          -1.1%     +0.4%

   wheel-sieve2         +21.2%    +20.7%

--------------------------------------------------------------------------------

            Min          -1.1%     -0.0%

            Max         +21.2%    +20.7%

 Geometric Mean          +0.2%     +0.2%

```

The regression in `wheel-sieve2` is due to reboxing that likely will go

away with the resolution of #18067. See !3282 for details.

Fixes #18187.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d3d055b8d10a549e42d18ae4859bc902f939f534">d3d055b8</a></strong>

<div>

<span>by Galen Huntington</span>

<i>at 2020-05-21T12:20:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify pitfalls of NegativeLiterals; see #18022.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1b508a9e14c7c894ff4f080f099f3947813f41ec">1b508a9e</a></strong>

<div>

<span>by Alexey Kuleshevich</span>

<i>at 2020-05-21T12:21:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix wording in primops documentation to reflect the correct reasoning:

* Besides resizing functions, shrinking ones also mutate the

  size of a mutable array and because of those two `sizeofMutabeByteArray`

  and `sizeofSmallMutableArray` are now deprecated

* Change reference in documentation to the newer functions `getSizeof*`

  instead of `sizeof*` for shrinking functions

* Fix incorrect mention of "byte" instead of "small"

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4ca0c8a17b9d3a7e8ff8a93cc9e83be5173f8e14">4ca0c8a1</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-05-21T12:21:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't variable-length encode magic iface constant.

We changed to use variable length encodings for many types by default,

including Word32. This makes sense for numbers but not when Word32 is

meant to represent four bytes.

I added a FixedLengthEncoding newtype to Binary who's instances

interpret their argument as a collection of bytes instead of a number.

We then use this when writing/reading magic numbers to the iface file.

I also took the libery to remove the dummy iface field.

This fixes #18180.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a127508137ba69d2fe1e563d2bbb9fdd9120ae85">a1275081</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-05-21T12:22:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a regression test for #11506

The testcase works now.

See explanation in https://gitlab.haskell.org/ghc/ghc/issues/11506#note_273202

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8a816e5fbe02c476f51ec92563cad8247ffc90ba">8a816e5f</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-05-21T12:23:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Sort deterministically metric output

Previously, we sorted according to the test name and way,

but the metrics (max_bytes_used/peak_megabytes_allocated etc.)

were appearing in nondeterministic order.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/566cc73f46d67e2b36fda95d0253067bb0ecc12f">566cc73f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-21T12:24:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move isDynLinkName into GHC.Types.Name

It doesn't belong into GHC.Unit.State

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3ddb90189212c5a5282cd9a0581cf288539206a4">3ddb9018</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-22T23:28:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Eta expand un-saturated primops

Now since we no longer try to predict CAFfyness we have no need for the

solution to #16846. Eta expanding unsaturated primop applications is

conceptually simpler, especially in the presence of levity polymorphism.

This essentially reverts cac8dc9f51e31e4c0a6cd9bc302f7e1bc7c03beb,

as suggested in #18079.

Closes #18079.

</pre>

</li>

</ul>

<h4>30 changed files:</h4>

<ul>

<li class="file-stats">

<a href="#587d266bb27a4dc3022bbed44dfa19849df3044c">

.gitlab-ci.yml

</a>

</li>

<li class="file-stats">

<a href="#157f7634c25bc6366cb7c9c9edb48e819dce38db">

.gitlab/ci.sh

</a>

</li>

<li class="file-stats">

<a href="#b25b374c2459de3e2aaed42163f492c8b8614385">

.gitlab/merge_request_templates/merge-request.md

</a>

</li>

<li class="file-stats">

<a href="#d0d96a6d03668aeab20ebe05e2c4ccb798c7e64c">

compiler/GHC.hs

</a>

</li>

<li class="file-stats">

<a href="#0887cf39c5cdf9cf8d6758f410d7dab3023c0d77">

compiler/GHC/Builtin/Names.hs

</a>

</li>

<li class="file-stats">

<a href="#57f535740df5928fb0193abc3b28ca771369d8fd">

compiler/GHC/Builtin/Names.hs-boot

</a>

</li>

<li class="file-stats">

<a href="#06764eb0158306b83ab1998d18316392a51838c2">

compiler/GHC/Builtin/Names/TH.hs

</a>

</li>

<li class="file-stats">

<a href="#a1519b7fe8a0d4b42e4aaa927fb6ab5b5da0fcdd">

compiler/GHC/Builtin/PrimOps.hs

</a>

</li>

<li class="file-stats">

<a href="#dc9d549002b8cd260ee6d1d2fb35877c74412f91">

compiler/GHC/Builtin/PrimOps.hs-boot

</a>

</li>

<li class="file-stats">

<a href="#377cfd14c1f92357465df995ec6537b074051322">

compiler/GHC/Builtin/Types.hs

</a>

</li>

<li class="file-stats">

<a href="#02362b473a022fb921814e97a6beba08107d38b1">

compiler/GHC/Builtin/Types/Literals.hs

</a>

</li>

<li class="file-stats">

<a href="#8a5cd068459120cddf3814e7b9e02003b87647ba">

compiler/GHC/Builtin/Types/Prim.hs

</a>

</li>

<li class="file-stats">

<a href="#8dc7109003a77f8a82e987dc1de31466aa956174">

compiler/GHC/Builtin/Uniques.hs

</a>

</li>

<li class="file-stats">

<a href="#6bcb866fdb5388db4ecc395e443a3af4888d9dd5">

compiler/GHC/Builtin/Uniques.hs-boot

</a>

</li>

<li class="file-stats">

<a href="#d95fdf6575459444666f72b2281534e0558a4ba0">

compiler/GHC/Builtin/Utils.hs

</a>

</li>

<li class="file-stats">

<a href="#451725cc4e5d443a3b7c2adcdf224840f953b7e2">

compiler/GHC/Builtin/primops.txt.pp

</a>

</li>

<li class="file-stats">

<a href="#2f6f8d6d05acc04b08fff94df4b3996c65b87892">

compiler/GHC/ByteCode/Asm.hs

</a>

</li>

<li class="file-stats">

<a href="#16db773e94d0938489b415eb3231cadb2565b84d">

compiler/GHC/ByteCode/InfoTable.hs

</a>

</li>

<li class="file-stats">

<a href="#073b107caa98ea426694eacd6c08b492801a51a0">

compiler/GHC/ByteCode/Instr.hs

</a>

</li>

<li class="file-stats">

<a href="#11e6f6a348be9920cecad0893a25350137524b4f">

compiler/GHC/ByteCode/Linker.hs

</a>

</li>

<li class="file-stats">

<a href="#5c66928780aaad0eb5888511dc4b0b08492c69fa">

compiler/GHC/ByteCode/Types.hs

</a>

</li>

<li class="file-stats">

<a href="#f73a4fa90a8eb153bccdcfcc9f63c15edcd66785">

compiler/GHC/Cmm.hs

</a>

</li>

<li class="file-stats">

<a href="#2635960270885615c76f7437d2eb6c5bd6082895">

compiler/GHC/Cmm/BlockId.hs

</a>

</li>

<li class="file-stats">

<a href="#db697f6aea9f93f1583f1d5c62d25570a1e07f73">

compiler/GHC/Cmm/CLabel.hs

</a>

</li>

<li class="file-stats">

<a href="#d088ba20f051734394bf7ca283f33ed8127bc8ab">

compiler/GHC/Cmm/CallConv.hs

</a>

</li>

<li class="file-stats">

<a href="#806448db91cc2906ebcc088107220a663d3d43eb">

compiler/GHC/Cmm/CommonBlockElim.hs

</a>

</li>

<li class="file-stats">

<a href="#359dccbd5e329f4f4f3c88b6d43f0ad5dd435fe3">

compiler/GHC/Cmm/ContFlowOpt.hs

</a>

</li>

<li class="file-stats">

<a href="#ae3febe6c6eb7c487d9f1021b113402ae6148bae">

compiler/GHC/Cmm/Dataflow.hs

</a>

</li>

<li class="file-stats">

<a href="#eae45922f6e633780395508f44c14a5ed7959e7a">

compiler/GHC/Cmm/Dataflow/Block.hs

</a>

</li>

<li class="file-stats">

<a href="#04d7c9e00896d6fa6990b4873e539e9c04c268bc">

compiler/GHC/Cmm/Dataflow/Collections.hs

</a>

</li>

</ul>

<h5>The diff was not included because it is too large.</h5>

</div>

<div class="footer" style="margin-top: 10px;">

<p style="font-size: small; color: #777;">

—

<br>

<a href="https://gitlab.haskell.org/ghc/ghc/-/compare/b0494a52537ac18e07560b5cc6e230d0cb2a8351...3ddb90189212c5a5282cd9a0581cf288539206a4">View it on GitLab</a>.

<br>

You're receiving this email because of your account on gitlab.haskell.org.

If you'd like to receive fewer emails, you can

adjust your notification settings.

</p>

</div>

</body>

</html>