<!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>

Simon Peyton Jones pushed to branch wip/T18126

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/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/1d118923df3e58c1b6bd39855e32fd48188c2bc3">1d118923</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-22T19:54:47-04:00</i>

</div>

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

This patch simplifies GHC to use simple subsumption.

  Ticket #17775

Implements GHC proposal #287

   https://github.com/ghc-proposals/ghc-proposals/blob/master/

   proposals/0287-simplify-subsumption.rst

All the motivation is described there; I will not repeat it here.

The implementation payload:

 * tcSubType and friends become noticably simpler, because it no

   longer uses eta-expansion when checking subsumption.

 * No deeplyInstantiate or deeplySkolemise

That in turn means that some tests fail, by design; they can all

be fixed by eta expansion.  There is a list of such changes below.

Implementing the patch led me into a variety of sticky corners, so

the patch includes several othe changes, some quite significant:

* I made String wired-in, so that

    "foo" :: String   rather than

    "foo" :: [Char]

  This improves error messages, and fixes #15679

* The pattern match checker relies on knowing about in-scope equality

  constraints, andd adds them to the desugarer's environment using

  addTyCsDs.  But the co_fn in a FunBind was missed, and for some reason

  simple-subsumption ends up with dictionaries there. So I added a

  call to addTyCsDs.  This is really part of #18049.

* I moved the ic_telescope field out of Implication and into

  ForAllSkol instead.  This is a nice win; just expresses the code

  much better.

* There was a bug in GHC.Tc.TyCl.Instance.tcDataFamInstHeader.

  We called checkDataKindSig inside tc_kind_sig, /before/

  solveEqualities and zonking.  Obviously wrong, easily fixed.

* solveLocalEqualitiesX: there was a whole mess in here, around

  failing fast enough.  I discovered a bad latent bug where we

  could successfully kind-check a type signature, and use it,

  but have unsolved constraints that could fill in coercion

  holes in that signature --  aargh.

  It's all explained in Note [Failure in local type signatures]

  in GHC.Tc.Solver. Much better now.

* I fixed a serious bug in anonymous type holes. IN

    f :: Int -> (forall a. a -> _) -> Int

  that "_" should be a unification variable at the /outer/

  level; it cannot be instantiated to 'a'.  This was plain

  wrong.  New fields mode_lvl and mode_holes in TcTyMode,

  and auxiliary data type GHC.Tc.Gen.HsType.HoleMode.

  This fixes #16292, but makes no progress towards the more

  ambitious #16082

* I got sucked into an enormous refactoring of the reporting of

  equality errors in GHC.Tc.Errors, especially in

      mkEqErr1

      mkTyVarEqErr

      misMatchMsg

      misMatchMsgOrCND

  In particular, the very tricky mkExpectedActualMsg function

  is gone.

  It took me a full day.  But the result is far easier to understand.

  (Still not easy!)  This led to various minor improvements in error

  output, and an enormous number of test-case error wibbles.

  One particular point: for occurs-check errors I now just say

     Can't match 'a' against '[a]'

  rather than using the intimidating language of "occurs check".

* Pretty-printing AbsBinds

Tests review

* Eta expansions

   T11305: one eta expansion

   T12082: one eta expansion (undefined)

   T13585a: one eta expansion

   T3102:  one eta expansion

   T3692:  two eta expansions (tricky)

   T2239:  two eta expansions

   T16473: one eta

   determ004: two eta expansions (undefined)

   annfail06: two eta (undefined)

   T17923: four eta expansions (a strange program indeed!)

   tcrun035: one eta expansion

* Ambiguity check at higher rank.  Now that we have simple

  subsumption, a type like

     f :: (forall a. Eq a => Int) -> Int

  is no longer ambiguous, because we could write

     g :: (forall a. Eq a => Int) -> Int

     g = f

  and it'd typecheck just fine.  But f's type is a bit

  suspicious, and we might want to consider making the

  ambiguity check do a check on each sub-term.  Meanwhile,

  these tests are accepted, whereas they were previously

  rejected as ambiguous:

     T7220a

     T15438

     T10503

     T9222

* Some more interesting error message wibbles

   T13381: Fine: one error (Int ~ Exp Int)

           rather than two (Int ~ Exp Int, Exp Int ~ Int)

   T9834:  Small change in error (improvement)

   T10619: Improved

   T2414:  Small change, due to order of unification, fine

   T2534:  A very simple case in which a change of unification order

           means we get tow unsolved constraints instead of one

   tc211: bizarre impredicative tests; just accept this for now

Updates Cabal submodule.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-23T22:33:20+01:00</i>

</div>

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