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

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/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/d830bbc9921bcc59164a0a18f0e0874ae4ce226e">d830bbc9</a></strong>

<div>

<span>by Adam Sandberg Ericsson</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: fix formatting and add some links

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/49301ad6226d9a83d110bee8c419615dd94f5ded">49301ad6</a></strong>

<div>

<span>by Andrew Martin</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement cstringLength# and FinalPtr

This function and its accompanying rule resolve issue #5218.

A future PR to the bytestring library will make the internal

Data.ByteString.Internal.unsafePackAddress compute string length

with cstringLength#. This will improve the status quo because it is

eligible for constant folding.

Additionally, introduce a new data constructor to ForeignPtrContents

named FinalPtr. This additional data constructor, when used in the

IsString instance for ByteString, leads to more Core-to-Core

optimization opportunities, fewer runtime allocations, and smaller

binaries.

Also, this commit re-exports all the functions from GHC.CString

(including cstringLength#) in GHC.Exts. It also adds a new test

driver. This test driver is used to perform substring matches on Core

that is dumped after all the simplifier passes. In this commit, it is

used to check that constant folding of cstringLength# works.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">simplCore: Ignore ticks in rule templates

This fixes #17619, where a tick snuck in to the template of a rule,

resulting in a panic during rule matching. The tick in question was

introduced via post-inlining, as discussed in `Note [Simplifying

rules]`. The solution we decided upon was to simply ignore ticks in the

rule template, as discussed in `Note [Tick annotations in RULE

matching]`.

Fixes #18162.

Fixes #17619.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/82cb8913b38d44ef20e928ff8b08f3f0770ebf80">82cb8913</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-05-23T13:38:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix #18145 and also avoid needless work with implicit vars

 - `forAllOrNothing` now is monadic, so we can trace whether we bind

   an explicit `forall` or not.

 - #18145 arose because the free vars calculation was needlessly

   complex. It is now greatly simplified.

 - Replaced some other implicit var code with `filterFreeVarsToBind`.

Co-authored-by: Ryan Scott <ryan.gl.scott@gmail.com>

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-23T13:39:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump process submodule

Fixes #17926.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/856adf54ab50fc3be66d17a0b94ba3074453b279">856adf54</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-23T13:40:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Clarify meaning of -haddock flag

Fixes #18206.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-23T13:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">git: Add ignored commits file

This can be used to tell git to ignore bulk renaming commits like the

recently-finished module hierarchy refactoring. Configured with,

    git config blame.ignoreRevsFile .git-ignore-revs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/63d30e60b9ab76ed48fa9539957e7b29a2a8c611">63d30e60</a></strong>

<div>

<span>by jneira</span>

<i>at 2020-05-24T01:54:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add hie-bios script for windows systems

It is a direct translation of the sh script

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/59182b88aaa72d346b480b6aa14a9244915e1189">59182b88</a></strong>

<div>

<span>by jneira</span>

<i>at 2020-05-24T01:54:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Honour previous values for CABAL and CABFLAGS

The immediate goal is let the hie-bios.bat script

set CABFLAGS with `-v0` and remove all cabal output

except the compiler arguments

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/932dc54e13a8e2f60ea90af98682cc1011b9533e">932dc54e</a></strong>

<div>

<span>by jneira</span>

<i>at 2020-05-24T01:54:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add specific configuration for windows in hie.yaml

</pre>

</li>

<li>

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

<div>

<span>by jneira</span>

<i>at 2020-05-24T01:54:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove not needed hie-bios output

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T01:55:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move Config module into GHC.Settings

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T01:55:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename GHC.Core.Arity into GHC.Core.Opt.Arity

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T01:55:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename GHC.Hs.Types into GHC.Hs.Type

See discussion in https://gitlab.haskell.org/ghc/ghc/issues/13009#note_268610

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T01:55:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add orderingTyCon to wiredInTyCons (#18185)

`Ordering` needs to be wired in for use in the built-in `CmpNat` and

`CmpSymbol` type families, but somehow it was never added to the list

of `wiredInTyCons`, leading to the various oddities observed

in #18185. Easily fixed by moving `orderingTyCon` from

`basicKnownKeyNames` to `wiredInTyCons`.

Fixes #18185.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01c43634d443bd3cc0b95b43a7180e12230b845d">01c43634</a></strong>

<div>

<span>by Matthew Pickering</span>

<i>at 2020-05-24T01:56:42-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/7a07aa718110071ee30eebadf0b4b372e8e7fc8e">7a07aa71</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T15:22:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix cross-compiler build (#16051)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15ccca16e2ecdde0a4e646c6d7515e00a7f364d3">15ccca16</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T15:22:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix distDir per stage

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-24T15:22:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix hp2ps error during cross-compilation

Fixed by @alp (see https://gitlab.haskell.org/ghc/ghc/issues/16051#note_274265)

</pre>

</li>

<li>

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

<div>

<span>by Joshua Price</span>

<i>at 2020-05-24T15:22:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make Unicode brackets opening/closing tokens (#18225)

The tokens `[|`, `|]`, `(|`, and `|)` are opening/closing tokens as

described in GHC Proposal #229. This commit makes the unicode

variants (`⟦`, `⟧`, `⦇`, and `⦈`) act the same as their ASCII

counterparts.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/013d71204be44d660f01f8eb255db2d48b832421">013d7120</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:17-04:00</i>

</div>

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

As noted in !3132, this has rather severe knock-on consequences in

user-code. We'll need to revisit this before merging something along

these lines.

This reverts commit 9749fe1223d182b1f8e7e4f7378df661c509f396.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Coverage: Drop redundant ad-hoc boot module check

To determine whether the module is a boot module

Coverage.addTicksToBinds was checking for a `boot` suffix in the module

source filename. This is quite ad-hoc and shouldn't be necessary; the

callsite in `deSugar` already checks that the module isn't a boot

module.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Coverage: Make tickBoxCount strict

This could otherwise easily cause a leak of (+) thunks.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Coverage: Make ccIndices strict

This just seems like a good idea.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/02e278eb2ace60cf2acadd2f632b51b9017d5b56">02e278eb</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Coverage: Don't produce ModBreaks if not HscInterpreted

emptyModBreaks contains a bottom and consequently it's important that we

don't use it unless necessary.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-25T09:48:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Coverage: Factor out addMixEntry

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/53814a6424240ab50201fdde81a6e7832c1aad3d">53814a64</a></strong>

<div>

<span>by Zubin Duggal</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add info about typeclass evidence to .hie files

See `testsuite/tests/hiefile/should_run/HieQueries.hs` and

`testsuite/tests/hiefile/should_run/HieQueries.stdout` for an example of this

We add two new fields, `EvidenceVarBind` and `EvidenceVarUse` to the

`ContextInfo` associated with an Identifier. These are associated with the

appropriate identifiers for the evidence variables collected when we come across

`HsWrappers`, `TcEvBinds` and `IPBinds` while traversing the AST.

Instance dictionary and superclass selector dictionaries from `tcg_insts` and

classes defined in `tcg_tcs` are also recorded in the AST as originating from

their definition span

This allows us to save a complete picture of the evidence constructed by the

constraint solver, and will let us report this to the user, enabling features

like going to the instance definition from the invocation of a class method(or

any other method taking a constraint) and finding all usages of a particular

instance.

Additionally,

- Mark NodeInfo with an origin so we can differentiate between bindings

  origininating in the source vs those in ghc

- Along with typeclass evidence info, also include information on Implicit

  Parameters

- Add a few utility functions to HieUtils in order to query the new info

Updates haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6604906c8cfa37f5780a6d5c40506b751b1740db">6604906c</a></strong>

<div>

<span>by Sebastian Graf</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make WorkWrap.Lib.isWorkerSmallEnough aware of the old arity

We should allow a wrapper with up to 82 parameters when the original

function had 82 parameters to begin with.

I verified that this made no difference on NoFib, but then again

it doesn't use huge records...

Fixes #18122.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-05-26T03:04:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enhance Note [About units] for Backpack

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-05-27T00:13:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">core-spec: Modify file paths according to new module hierarchy

This patch updates file paths according to new module hierarchy [1]:

  * GHC/Core.hs                <= coreSyn/CoreSyn.hs

  * GHC/Core/Coercion.hs       <= types/Coercion.hs

  * GHC/Core/Coercion/Axiom.hs <= types/CoAxiom.hs

  * GHC/Core/Coercion/Opt.hs   <= types/OptCoercion.hs

  * GHC/Core/DataCon.hs        <= basicTypes/DataCon.hs

  * GHC/Core/FamInstEnv.hs     <= types/FamInstEnv.hs

  * GHC/Core/Lint.hs           <= coreSyn/CoreLint.hs

  * GHC/Core/Subst.hs          <= coreSyn/CoreSubst.hs

  * GHC/Core/TyCo/Rep.hs       <= types/TyCoRep.hs

  * GHC/Core/TyCon.hs          <= types/TyCon.hs

  * GHC/Core/Type.hs           <= types/Type.hs

  * GHC/Core/Unify.hs          <= types/Unify.hs

  * GHC/Types/Literal.hs       <= basicTypes/Literal.hs

  * GHC/Types/Var.hs           <= basicTypes/Var.hs

[1]: https://gitlab.haskell.org/ghc/ghc/-/wikis/Make-GHC-codebase-more-modular

[skip ci]

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-27T00:14:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">eventlog: Fix racy flushing

Previously no attempt was made to avoid multiple threads writing their

capability-local eventlog buffers to the eventlog writer simultaneously.

This could result in multiple eventlog streams being interleaved. Fix

this by documenting that the EventLogWriter's write() and flush()

functions may be called reentrantly and fix the default writer to

protect its FILE* by a mutex.

Fixes #18210.

</pre>

</li>

<li>

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

<div>

<span>by Joshua Price</span>

<i>at 2020-05-27T00:15:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make `identifier` parse unparenthesized `->` (#18060)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/28deee2872d2501a781ae5b89f1db3dbf796ee74">28deee28</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-28T16:23:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.Core.Unfold: Refactor traceInline

This reduces duplication as well as fixes a bug wherein -dinlining-check

would override -ddump-inlinings. Moreover, the new variant

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-28T16:23:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid unnecessary allocations due to tracing utilities

While ticky-profiling the typechecker I noticed that hundreds of

millions of SDocs are being allocated just in case -ddump-*-trace is

enabled. This is awful.

We avoid this by ensuring that the dump flag check is inlined into the

call site, ensuring that the tracing document needn't be allocated

unless it's actually needed.

See Note [INLINE conditional tracing utilities] for details.

Fixes #18168.

Metric Decrease:

  T9961

  haddock.Cabal

  haddock.base

  haddock.compiler

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-05-28T16:23:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add Semigroup/Monoid for Q (#18123)

</pre>

</li>

<li>

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

<div>

<span>by Xavier Denis</span>

<i>at 2020-05-28T16:24:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix #18071

Run the core linter on candidate instances to ensure they are

well-kinded.

Better handle quantified constraints by using a CtWanted to avoid

having unsolved constraints thrown away at the end by the solver.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-28T16:25:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">FloatOut: Only eta-expand dead-end RHS if arity will increase (#18231)

Otherwise we risk turning trivial RHS into non-trivial RHS, introducing

unnecessary bindings in the next Simplifier run, resulting in more

churn.

Fixes #18231.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/08dab5f74e021ad054112cc5f6bb7e55d8796cd7">08dab5f7</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-05-28T16:25:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DmdAnal: Recognise precise exceptions from case alternatives (#18086)

Consider

```hs

m :: IO ()

m = do

  putStrLn "foo"

  error "bar"

```

`m` (from #18086) always throws a (precise or imprecise) exception or

diverges. Yet demand analysis infers `<L,A>` as demand signature instead

of `<L,A>x` for it.

That's because the demand analyser sees `putStrLn` occuring in a case

scrutinee and decides that it has to `deferAfterPreciseException`,

because `putStrLn` throws a precise exception on some control flow

paths. This will mask the `botDiv` `Divergence`of the single case alt

containing `error` to `topDiv`. Since `putStrLn` has `topDiv` itself,

the final `Divergence` is `topDiv`.

This is easily fixed: `deferAfterPreciseException` works by `lub`ing

with the demand type of a virtual case branch denoting the precise

exceptional control flow. We used `nopDmdType` before, but we can be

more precise and use `exnDmdType`, which is `nopDmdType` with `exnDiv`.

Now the `Divergence` from the case alt will degrade `botDiv` to `exnDiv`

instead of `topDiv`, which combines with the result from the scrutinee

to `exnDiv`, and all is well.

Fixes #18086.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-28T16:25:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Ticky-ticky: Record DataCon name in ticker name

This makes it significantly easier to spot the nature of

allocations regressions and comes at a reasonably low cost.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-28T16:26:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't track GHC's verbosity argument

Teach hadrian to ignore GHC's -v argument in its recompilation check,

thus fixing #18131.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-28T16:27:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rip out CmmStackInfo(updfr_space)

As noted in #18232, this field is currently completely unused and

moreover doesn't have a clear meaning.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-05-29T01:38:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix "build/elem" RULE.

An redundant constraint prevented the rule from matching.

Fixing this allows a call to elem on a known list to be translated

into a series of equality checks, and eventually a simple case

expression.

Surprisingly this seems to regress elem for strings. To avoid

this we now also allow foldrCString to inline and add an UTF8

variant. This results in elem being compiled to a tight

non-allocating loop over the primitive string literal which

performs a linear search.

In the process this commit adds UTF8 variants for some of the

functions in GHC.CString. This is required to make this work for

both ASCII and UTF8 strings.

There are also small tweaks to the CString related rules.

We now allow ourselfes the luxury to compare the folding function

via eqExpr, which helps to ensure the rule fires before we inline

foldrCString*. Together with a few changes to allow matching on both

the UTF8 and ASCII variants of the CString functions.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-29T01:39:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CoreToStg: Add Outputable ArgInfo instance

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-29T01:39:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make Lint check return type of a join point

Consider

   join x = rhs in body

It's important that the type of 'rhs' is the same as the type of

'body', but Lint wasn't checking that invariant.

Now it does!  This was exposed by investigation into !3113.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-05-29T01:39:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do not float join points in exprIsConApp_maybe

We hvae been making exprIsConApp_maybe cleverer in recent times:

    commit b78cc64e923716ac0512c299f42d4d0012306c05

    Date:   Thu Nov 15 17:14:31 2018 +0100

    Make constructor wrappers inline only during the final phase

    commit 7833cf407d1f608bebb1d38bb99d3035d8d735e6

    Date:   Thu Jan 24 17:58:50 2019 +0100

    Look through newtype wrappers (Trac #16254)

    commit c25b135ff5b9c69a90df0ccf51b04952c2dc6ee1

    Date:   Thu Feb 21 12:03:22 2019 +0000

    Fix exprIsConApp_maybe

But alas there was still a bug, now immortalised in

  Note [Don't float join points]

in SimpleOpt.

It's quite hard to trigger because it requires a dead

join point, but it came up when compiling Cabal

Cabal.Distribution.Fields.Lexer.hs, when working on

!3113.

Happily, the fix is extremly easy.  Finding the

bug was not so easy.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-29T01:39:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow simplification through runRW#

Because runRW# inlines so late, we were previously able to do very

little simplification across it. For instance, given even a simple

program like

    case runRW# (\s -> let n = I# 42# in n) of

      I# n# -> f n#

we previously had no way to avoid the allocation of the I#.

This patch allows the simplifier to push strict contexts into the

continuation of a runRW# application, as explained in

in Note [Simplification of runRW#] in GHC.CoreToStg.Prep.

Fixes #15127.

Metric Increase:

    T9961

Metric Decrease:

    ManyConstructors

Co-Authored-By: Simon Peyton-Jone <simonpj@microsoft.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/277c2f26e6966e0cfaa1ddcd297af44766f37958">277c2f26</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-29T01:39:55-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>

<li>

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

<div>

<span>by Simon Jakobi</span>

<i>at 2020-05-29T01:40:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Scrap deprecation plan for Data.Monoid.{First,Last}

See the discussion on the libraries mailing list for context:

https://mail.haskell.org/pipermail/libraries/2020-April/030357.html

</pre>

</li>

<li>

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

<div>

<span>by Jeremy Schlatter</span>

<i>at 2020-05-29T01:41:12-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/998450f4c67e8f701455927c9619b8d53f2b733b">998450f4</a></strong>

<div>

<span>by Gleb Popov</span>

<i>at 2020-05-29T01:41:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Always define USE_PTHREAD_FOR_ITIMER for FreeBSD.

</pre>

</li>

<li>

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

<div>

<span>by Alp Mestanogullari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: introduce 'install' target

Its logic is very simple. It `need`s the `binary-dist-dir` target

and runs suitable `configure` and `make install` commands for the

user. A new `--prefix` command line argument is introduced to

specify where GHC should be installed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67738db10010fd28a8e997b5c8f83ea591b88a0e">67738db1</a></strong>

<div>

<span>by Travis Whitaker</span>

<i>at 2020-05-29T13:34:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Build a threaded stage 1 if the bootstrapping GHC supports it.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-05-29T13:35:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PPC NCG: No per-symbol .section ".toc" directives

All position independent symbols are collected during code generation

and emitted in one go. Prepending each symbol with a .section ".toc"

directive is redundant. This patch drops the per-symbol directives

leading to smaller assembler files.

Fixes #18250

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4413828b7c507872c56719fb8920e1c2322830f8">4413828b</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-30T06:07:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Teach getNumProcessors to return available processors

Previously we would report the number of physical processors, which

can be quite wrong in a containerized setting. Now we rather return how

many processors are in our affinity mask when possible.

I also refactored the code to prefer platform-specific since this will

report logical CPUs instead of physical (using

`machdep.cpu.thread_count` on Darwin and `cpuset_getaffinity` on FreeBSD).

Fixes #14781.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1449435c7bf1075f5cd11098d8c98b99f8fe150a">1449435c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-30T06:07:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Note change in getNumProcessors in users guide

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-30T06:07:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Drop compatibility shims for Windows Vista

We can now assume that the thread and processor group interfaces are

available.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PPC NCG: Fix .size directive on powerpc64 ELF v1

Thanks to Sergei Trofimovich for pointing out the issue.

Fixes #18237

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Optimize GHC.Utils.Monad.

Many functions in this module are recursive and as such are marked

loop breakers. Which means they are unlikely to get an unfolding.

This is *bad*. We always want to specialize them to specific Monads.

Which requires a visible unfolding at the use site.

I rewrote the recursive ones from:

    foo f x = ... foo x' ...

to

    foo f x = go x

      where

        go x = ...

As well as giving some pragmas to make all of them available

for specialization.

The end result is a reduction of allocations of about -1.4% for

nofib/spectral/simple/Main.hs when compiled with `-O`.

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

Metric Decrease:

    T12425

    T14683

    T5631

    T9233

    T9675

    T9961

    WWRec

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

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-05-30T06:09:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Windows: Bump Windows toolchain to 0.2

</pre>

</li>

<li>

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

<div>

<span>by Zubin Duggal</span>

<i>at 2020-05-30T06:10:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify contexts in GHC.Iface.Ext.Ast

</pre>

</li>

<li>

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

<div>

<span>by Daniel Gröber</span>

<i>at 2020-06-01T06:32:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cleanup OVERWRITING_CLOSURE logic

The code is just more confusing than it needs to be. We don't need to mix

the threaded check with the ldv profiling check since ldv's init already

checks for this. Hence they can be two separate checks. Taking the sanity

checking into account is also cleaner via DebugFlags.sanity. No need for

checking the DEBUG define.

The ZERO_SLOP_FOR_LDV_PROF and ZERO_SLOP_FOR_SANITY_CHECK definitions the

old code had also make things a lot more opaque IMO so I removed those.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6159559b5eb71ed7287998e954f96cdfb2d48f04">6159559b</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-06-01T06:32:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix OVERWRITING_CLOSURE assuming closures are not inherently used

The new ASSERT in LDV_recordDead() was being tripped up by MVars when

removeFromMVarBlockedQueue() calls OVERWRITING_CLOSURE() via

OVERWRITE_INFO().

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/389920858e0b9efe5234cb7dac55d06e955768f7">38992085</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-06-01T06:32:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Always zero shrunk mutable array slop when profiling

When shrinking arrays in the profiling way we currently don't always zero

the leftover slop. This means we can't traverse such closures in the heap

profiler. The old Note [zeroing slop] and #8402 have some rationale for why

this is so but I belive the reasoning doesn't apply to mutable

closures. There users already have to ensure multiple threads don't step on

each other's toes so zeroing should be safe.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:33:37-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:33:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add test for desugaring of PostfixOperators

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:33:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">HsToCore: Eta expand left sections

Strangely, the comment next to this code already alluded to the fact

that even simply eta-expanding will sacrifice laziness. It's quite

unclear how we regressed so far.

See #18151.

</pre>

</li>

<li>

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

<div>

<span>by Kirill Elagin</span>

<i>at 2020-06-01T06:34:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Winferred-safe-imports: Do not exit with error

Currently, when -Winferred-safe-imports is enabled, even when it is not

turned into an error, the compiler will still exit with exit code 1 if

this warning was emitted.

Make sure it is really treated as a warning.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:34:58-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Bodigrim</span>

<i>at 2020-06-01T06:35:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify description of fromListN</pre>

</li>

<li>

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

<div>

<span>by Bodigrim</span>

<i>at 2020-06-01T06:35:36-04:00</i>

</div>

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

</li>

<li>

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

<div>

<span>by fendor</span>

<i>at 2020-06-01T06:36:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add `isInScope` check to `lintCoercion`

Mirrors the behaviour of `lintType`.

</pre>

</li>

<li>

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

<div>

<span>by fendor</span>

<i>at 2020-06-01T06:36:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Lint rhs of IfaceRule

</pre>

</li>

<li>

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

<div>

<span>by Jeremy Schlatter</span>

<i>at 2020-06-01T06:37:00-04:00</i>

</div>

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

The duplicate "orphan instance" phrase here doesn't make sense, and was

probably an accident.

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-01T06:37:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Modify aclocal.m4 according to new module hierarchy

This patch updates file paths according to new module hierarchy [1]:

* Rename:

  * compiler/GHC/Parser.hs       <= compiler/parser/Parser.hs

  * compiler/GHC/Parser/Lexer.hs <= compiler/Parser/Lexer.hs

* Add:

  * compiler/GHC/Cmm/Lexer.hs

[1]: https://gitlab.haskell.org/ghc/ghc/-/wikis/Make-GHC-codebase-more-modular

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15857ad856b6072d2c6a34b2bf7aa7316d7e2b12">15857ad8</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:38:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Don't fail if we can't unlink __symlink_test

Afterall, it's possible we were unable to create it due to lack of

symlink permission.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:38:26-04:00</i>

</div>

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

Tamar reported that he saw crashes due to unhandled exceptions.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:38:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite/perf_notes: Fix ill-typed assignments

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:38:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite/testutil: Fix bytes/str mismatch

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7002d0cbbe1581dd157b530e95c62195f37cfe00">7002d0cb</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T06:38:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Work around spurious mypy failure

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/11390e3ab038a18c2a7bf6b2423657614a439afb">11390e3a</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-01T06:39:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up file paths for new module hierarchy

This updates comments only.

This patch replaces file references according to new module hierarchy.

See also:

* https://gitlab.haskell.org/ghc/ghc/-/wikis/Make-GHC-codebase-more-modular

* https://gitlab.haskell.org/ghc/ghc/issues/13009

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-01T06:39:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Modify file paths to module paths for new module hierarchy

This updates comments only.

This patch replaces module references according to new module

hierarchy [1][2].

For files under the `compiler/` directory, I replace them as

module paths instead of file paths. For instance,

`GHC.Unit.State` instead of `compiler/GHC/Unit/State.hs` [3].

For current and future haddock's markup, this patch encloses

the module name with "" [4].

[1]: https://gitlab.haskell.org/ghc/ghc/-/wikis/Make-GHC-codebase-more-modular

[2]: https://gitlab.haskell.org/ghc/ghc/issues/13009

[3]: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3375#note_276613

[4]: https://haskell-haddock.readthedocs.io/en/latest/markup.html#linking-to-modules

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/68b71c4a99ef7c009e0095823950cd12408ad7fe">68b71c4a</a></strong>

<div>

<span>by Tom Ellis</span>

<i>at 2020-06-01T06:39:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename the singleton tuple GHC.Tuple.Unit to GHC.Tuple.Solo

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/95da76c2b9ffe2a4fb4230de0061918de3fc89a9">95da76c2</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-01T06:40:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix binary-dist target for cross-compilation

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/730fcd54467e82083d56fa87e44bbe346458c531">730fcd54</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-06-01T06:41:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve parser error messages for the @-operator

Since GHC diverges from the Haskell Report by allowing the user

to define (@) as an infix operator, we better give a good

error message when the user does so unintentionally.

In general, this is rather hard to do, as some failures will be

discovered only in the renamer or the type checker:

        x :: (Integer, Integer)

        x @ (a, b) = (1, 2)

This patch does *not* address this general case.

However, it gives much better error messages when the binding

is not syntactically valid:

        pairs xs @ (_:xs') = zip xs xs'

Before this patch, the error message was rather puzzling:

        <interactive>:1:1: error: Parse error in pattern: pairs

After this patch, the error message includes a hint:

        <interactive>:1:1: error:

            Parse error in pattern: pairs

            In a function binding for the ‘@’ operator.

            Perhaps you meant an as-pattern, which must not be surrounded by whitespace

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-06-01T06:41:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve parser error messages for TypeApplications

With this patch, we always parse  f @t  as a type application,

thereby producing better error messages.

This steals two syntactic forms:

* Prefix form of the @-operator in expressions. Since the @-operator is

  a divergence from the Haskell Report anyway, this is not a major loss.

* Prefix form of @-patterns. Since we are stealing loose infix form

  anyway, might as well sacrifice the prefix form for the sake of much

  better error messages.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-06-01T06:41:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve parser error messages for TemplateHaskellQuotes

While [e| |], [t| |], [d| |], and so on, steal syntax from list

comprehensions, [| |] and [|| ||] do not steal any syntax.

Thus we can improve error messages by always accepting them in the

lexer. Turns out the renamer already performs necessary validation.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/120aedbdff7dbb9b394dadabb1f431608b42de67">120aedbd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-01T16:07:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Disable use of ld.lld on ARMv7

It turns out that lld non-deterministically fails on ARMv7. I suspect

this may be due to the a kernel regression as this only started

happening when we upgraded to 5.4. Nevertheless, easily avoided by

simply sticking with gold.

Works around #18280.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-02T13:03:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Ensure that workaround for #18280 applies to bindisttest

We need to ensure that the `configure` flags working around #18280 are

propagated to the bindisttest `configure` as well.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-03T17:55:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Allow ARMv7 job to fail

Due to #18298.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32a4ae90b50cc56f2955f489ad0cf8c7ff5e131a">32a4ae90</a></strong>

<div>

<span>by John Ericson</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up boot vs non-boot disambiguating types

We often have (ModuleName, Bool) or (Module, Bool) pairs for "extended"

module names (without or with a unit id) disambiguating boot and normal

modules. We think this is important enough across the compiler that it

deserves a new nominal product type. We do this with synnoyms and a

functor named with a `Gen` prefix, matching other newly created

definitions.

It was also requested that we keep custom `IsBoot` / `NotBoot` sum type.

So we have it too. This means changing many the many bools to use that

instead.

Updates `haddock` submodule.

</pre>

</li>

<li>

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

<div>

<span>by Niklas Hambüchen</span>

<i>at 2020-06-04T04:35:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: Add more details on InterruptibleFFI.

Details from https://gitlab.haskell.org/ghc/ghc/issues/8684

and https://github.com/takano-akio/filelock/pull/7#discussion_r280332430

</pre>

</li>

<li>

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

<div>

<span>by Andrew Martin</span>

<i>at 2020-06-04T04:36:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow finalizeForeignPtr to be called on FinalPtr/PlainPtr.

MR 2165 (commit 49301ad6226d9a83d110bee8c419615dd94f5ded) regressed

finalizeForeignPtr by throwing exceptions when PlainPtr was encounterd.

This regression did not make it into a release of GHC. Here, the

original behavior is restored, and FinalPtr is given the same treatment

as PlainPtr.

</pre>

</li>

<li>

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

<div>

<span>by Luke Lau</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix documentation on type families not being extracted

It looks like the location of the Names used for CoAxioms on type

families are now located at their type constructors. Previously, Docs.hs

thought the Names were located in the RHS, so the RealSrcSpan in the

instanceMap and getInstLoc didn't match up. Fixes #18241

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6735b9d94605b4c7f75e70339bfaa4207f23e52b">6735b9d9</a></strong>

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.Hs.Instances: Compile with -O0

This module contains exclusively Data instances, which are going to be

slow no matter what we do. Furthermore, they are incredibly slow to

compile with optimisation (see #9557). Consequently we compile this with

-O0.  See #18254.

</pre>

</li>

<li>

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

<div>

<span>by nineonine</span>

<i>at 2020-06-04T04:37:59-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-04T04:38:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add Windows-specific implementation of rtsSleep

Previously we would use the POSIX path, which uses `nanosleep`. However,

it turns out that `nanosleep` is provided by `libpthread` on Windows. In

general we don't want to incur such a dependency. Avoid this by simply

using `Sleep` on Windows.

Fixes #18272.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-04T04:38:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler: Disable use of process jobs with process < 1.6.9

Due to #17926.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-04T04:55:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[linker] Adds void printLoadedObjects(void);

This allows us to dump in-memory object code locations for debugging.

Fixup printLoadedObjects prototype

</pre>

</li>

<li>

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

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-06-05T03:18:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: fix sign confusion in log1mexp implementation (fix #17125)

author: claude (https://gitlab.haskell.org/trac-claude)

The correct threshold for log1mexp is -(log 2) with the current specification

of log1mexp. This change improves accuracy for large negative inputs.

To avoid code duplication, a small helper function is added;

it isn't the default implementation in Floating because it needs Ord.

This patch does nothing to address that the Haskell specification is

different from that in common use in other languages.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-05T09:27:50-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 and haddock submodules.

Metric Increase:

  T12150

  T12234

  T5837

  haddock.base

Metric Decrease:

  haddock.compiler

  haddock.Cabal

  haddock.base

Merge note: This appears to break the

`UnliftedNewtypesDifficultUnification` test. It has been marked as

broken in the interest of merging.

(cherry picked from commit 66b7b195cb3dce93ed5078b80bf568efae904cc5)

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-05T14:21:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify bindLHsTyVarBndrs and bindHsQTyVars

Both `bindLHsTyVarBndrs` and `bindHsQTyVars` take two separate

`Maybe` arguments, which I find terribly confusing. Thankfully, it's

possible to remove one `Maybe` argument from each of these functions,

which this patch accomplishes:

* `bindHsQTyVars` takes a `Maybe SDoc` argument, which is `Just` if

  GHC should warn about any of the quantified type variables going

  unused. However, every call site uses `Nothing` in practice. This

  makes sense, since it doesn't really make sense to warn about

  unused type variables bound by an `LHsQTyVars`. For instance, you

  wouldn't warn about the `a` in `data Proxy a = Proxy` going unused.

  As a result, I simply remove this `Maybe SDoc` argument altogether.

* `bindLHsTyVarBndrs` also takes a `Maybe SDoc` argument for the same

  reasons that `bindHsQTyVars` took one. To make things more

  confusing, however, `bindLHsTyVarBndrs` also takes a separate

  `HsDocContext` argument, which is pretty-printed (to an `SDoc`) in

  warnings and error messages.

  In practice, the `Maybe SDoc` and the `HsDocContext` often contain

  the same text. See the call sites for `bindLHsTyVarBndrs` in

  `rnFamInstEqn` and `rnConDecl`, for instance. There are only a

  handful of call sites where the text differs between the

  `Maybe SDoc` and `HsDocContext` arguments:

  * In `rnHsRuleDecl`, where the `Maybe SDoc` says "`In the rule`"

    and the `HsDocContext` says "`In the transformation rule`".

  * In `rnHsTyKi`/`rn_ty`, where the `Maybe SDoc` says

    "`In the type`" but the `HsDocContext` is inhereted from the

    surrounding context (e.g., if `rnHsTyKi` were called on a

    top-level type signature, the `HsDocContext` would be

    "`In the type signature`" instead)

  In both cases, warnings/error messages arguably _improve_ by

  unifying making the `Maybe SDoc`'s text match that of the

  `HsDocContext`. As a result, I decided to remove the `Maybe SDoc`

  argument to `bindLHsTyVarBndrs` entirely and simply reuse the text

  from the `HsDocContext`. (I decided to change the phrase

  "transformation rule" to "rewrite rule" while I was in the area.)

  The `Maybe SDoc` argument has one other purpose: signaling when to

  emit "`Unused quantified type variable`" warnings. To recover this

  functionality, I replaced the `Maybe SDoc` argument with a

  boolean-like `WarnUnusedForalls` argument. The only

  `bindLHsTyVarBndrs` call site that chooses _not_ to emit these

  warnings in `bindHsQTyVars`.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-07T08:46:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Add missing deriveConstants dependency on ghcplatform.h

deriveConstants wants to compile C sources which #include PosixSource.h,

which itself #includes ghcplatform.h. Make sure that Hadrian knows

about this dependency.

Fixes #18290.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-07T08:46:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-prim needs to depend on libc and libm

libm is just an empty shell on musl, and all the math functions are contained in

libc.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-07T08:46:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disable DLL loading if without system linker

Some platforms (musl, aarch64) do not have a working dynamic linker

implemented in the libc, even though we might see dlopen.  It will

ultimately just return that this is not supported.  Hence we'll add

a flag to the compiler to flat our disable loading dlls.  This is

needed as we will otherwise try to load the shared library even

if this will subsequently fail.  At that point we have given up

looking for static options though.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-07T08:46:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Range is actually +/-2^32, not +/-2^31

See also: https://static.docs.arm.com/ihi0056/g/aaelf64.pdf

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-07T10:49:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">OccurAnal: Avoid exponential behavior due to where clauses

Previously the `Var` case of `occAnalApp` could in some cases (namely

in the case of `runRW#` applications) call `occAnalRhs` two. In the case

of nested `runRW#`s this results in exponential complexity. In some

cases the compilation time that resulted would be very long indeed

(see #18296).

Fixes #18296.

Metric Decrease:

    T9961

    T12150

    T12234

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-09T08:05:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add link to GHC's wiki in the GHC API header

This adds a URL to point to GHC's wiki in the GHC API header.

Newcomers could easily find more information from the GHC API's

web like [1].

[1]: Current version, https://ghc.gitlab.haskell.org/ghc/doc/libraries/ghc-8.11.0.20200604/index.html

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/72c7fe9a1e147dfeaf043f6d591d724a126cce45">72c7fe9a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-09T08:06:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make GADT constructors adhere to the forall-or-nothing rule properly

Issue #18191 revealed that the types of GADT constructors don't quite

adhere to the `forall`-or-nothing rule. This patch serves to clean up

this sad state of affairs somewhat. The main change is not in the

code itself, but in the documentation, as this patch introduces two

sections to the GHC User's Guide:

* A "Formal syntax for GADTs" section that presents a BNF-style

  grammar for what is and isn't allowed in GADT constructor types.

  This mostly exists to codify GHC's existing behavior, but it also

  imposes a new restriction that addresses #18191: the outermost

  `forall` and/or context in a GADT constructor is not allowed to be

  surrounded by parentheses. Doing so would make these

  `forall`s/contexts nested, and GADTs do not support nested

  `forall`s/contexts at present.

* A "`forall`-or-nothing rule" section that describes exactly what

  the `forall`-or-nothing rule is all about. Surprisingly, there was

  no mention of this anywhere in the User's Guide up until now!

To adhere the new specification in the "Formal syntax for GADTs"

section of the User's Guide, the following code changes were made:

* A new function, `GHC.Hs.Type.splitLHsGADTPrefixTy`, was introduced.

  This is very much like `splitLHsSigmaTy`, except that it avoids

  splitting apart any parentheses, which can be syntactically

  significant for GADT types. See

  `Note [No nested foralls or contexts in GADT constructors]` in

  `GHC.Hs.Type`.

* `ConDeclGADTPrefixPs`, an extension constructor for `XConDecl`, was

  introduced so that `GHC.Parser.PostProcess.mkGadtDecl` can return

  it when given a prefix GADT constructor. Unlike `ConDeclGADT`,

  `ConDeclGADTPrefixPs` does not split the GADT type into its argument

  and result types, as this cannot be done until after the type is

  renamed (see `Note [GADT abstract syntax]` in `GHC.Hs.Decls` for why

  this is the case).

* `GHC.Renamer.Module.rnConDecl` now has an additional case for

  `ConDeclGADTPrefixPs` that (1) splits apart the full `LHsType` into

  its `forall`s, context, argument types, and result type, and

  (2) checks for nested `forall`s/contexts. Step (2) used to be

  performed the typechecker (in `GHC.Tc.TyCl.badDataConTyCon`) rather

  than the renamer, but now the relevant code from the typechecker

  can simply be deleted.

  One nice side effect of this change is that we are able to give a

  more accurate error message for GADT constructors that use visible

  dependent quantification (e.g., `MkFoo :: forall a -> a -> Foo a`),

  which improves the stderr in the `T16326_Fail6` test case.

Fixes #18191. Bumps the Haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-10T03:39:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Always use rnImplicitBndrs to bring implicit tyvars into scope

This implements a first step towards #16762 by changing the renamer

to always use `rnImplicitBndrs` to bring implicitly bound type

variables into scope. The main change is in `rnFamInstEqn` and

`bindHsQTyVars`, which previously used _ad hoc_ methods of binding

their implicit tyvars.

There are a number of knock-on consequences:

* One of the reasons that `rnFamInstEqn` used an _ad hoc_ binding

  mechanism was to give more precise source locations in

  `-Wunused-type-patterns` warnings. (See

  https://gitlab.haskell.org/ghc/ghc/issues/16762#note_273343 for an

  example of this.) However, these warnings are actually a little

  _too_ precise, since implicitly bound type variables don't have

  exact binding sites like explicitly bound type variables do.

  A similar problem existed for

  "`Different names for the same type variable`" errors involving

  implicit tyvars bound by `bindHsQTyVars`.

  Therefore, we simply accept the less precise (but more accurate)

  source locations from `rnImplicitBndrs` in `rnFamInstEqn` and

  `bindHsQTyVars`. See

  `Note [Source locations for implicitly bound type variables]` in

  `GHC.Rename.HsType` for the full story.

* In order for `rnImplicitBndrs` to work in `rnFamInstEqn`, it needs

  to be able to look up names from the parent class (in the event

  that we are renaming an associated type family instance). As a

  result, `rnImplicitBndrs` now takes an argument of type

  `Maybe assoc`, which is `Just` in the event that a type family

  instance is associated with a class.

* Previously, GHC kept track of three type synonyms for free type

  variables in the renamer: `FreeKiTyVars`, `FreeKiTyVarsDups`

  (which are allowed to contain duplicates), and

  `FreeKiTyVarsNoDups` (which contain no duplicates). However, making

  is a distinction between `-Dups` and `-NoDups` is now pointless, as

  all code that returns `FreeKiTyVars{,Dups,NoDups}` will eventually

  end up being passed to `rnImplicitBndrs`, which removes duplicates.

  As a result, I decided to just get rid of `FreeKiTyVarsDups` and

  `FreeKiTyVarsNoDups`, leaving only `FreeKiTyVars`.

* The `bindLRdrNames` and `deleteBys` functions are now dead code, so

  I took the liberty of removing them.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2487912938f188cb264e4a11d21bf750adccc5e7">24879129</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-10T03:39:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify leaf module names for new module hierarchy

This updates comments only.

This patch replaces leaf module names according to new module

hierarchy [1][2] as followings:

* Expand leaf names to easily find the module path:

  for instance, `Id.hs` to `GHC.Types.Id`.

* Modify leaf names according to new module hierarchy:

  for instance, `Convert.hs` to `GHC.ThToHs`.

* Fix typo:

  for instance, `GHC.Core.TyCo.Rep.hs` to `GHC.Core.TyCo.Rep`

See also !3375

[1]: https://gitlab.haskell.org/ghc/ghc/-/wikis/Make-GHC-codebase-more-modular

[2]: https://gitlab.haskell.org/ghc/ghc/issues/13009

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/92de9e25aa1a6f7aa73154868521bcf4f0dc9d1e">92de9e25</a></strong>

<div>

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

<i>at 2020-06-10T03:41:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Remove unused GET_ENTRY closure macro

This macro is not used and got broken in the meantime, as ENTRY_CODE was

deleted.

</pre>

</li>

<li>

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

<div>

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

<i>at 2020-06-10T03:41:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix -fkeep-cafs flag name in users guide

</pre>

</li>

<li>

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

<div>

<span>by Shayne Fletcher</span>

<i>at 2020-06-10T04:14:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Expose impliedGFlags, impledOffGFlags, impliedXFlags

</pre>

</li>

<li>

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

<div>

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

<i>at 2020-06-10T04:14:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cross-module LambdaFormInfo passing

- Store LambdaFormInfos of exported Ids in interface files

- Use them in importing modules

This is for optimization purposes: if we know LambdaFormInfo of imported

Ids we can generate more efficient calling code, see `getCallMethod`.

Exporting (putting them in interface files or in ModDetails) and

importing (reading them from interface files) are both optional. We

don't assume known LambdaFormInfos anywhere and do not change how we

call Ids with unknown LambdaFormInfos.

Runtime, allocation, and residency numbers when building

Cabal-the-library (commit 0d4ee7ba3):

(Log and .hp files are in the MR: !2842)

|     | GHC HEAD | This patch | Diff           |

|-----|----------|------------|----------------|

| -O0 |  0:35.89 |    0:34.10 | -1.78s, -4.98% |

| -O1 |  2:24.01 |    2:23.62 | -0.39s, -0.27% |

| -O2 |  2:52.23 |    2:51.35 | -0.88s, -0.51% |

|     | GHC HEAD        | This patch      | Diff                       |

|-----|-----------------|-----------------|----------------------------|

| -O0 |  54,843,608,416 |  54,878,769,544 |  +35,161,128 bytes, +0.06% |

| -O1 | 227,136,076,400 | 227,569,045,168 | +432,968,768 bytes, +0.19% |

| -O2 | 266,147,063,296 | 266,749,643,440 | +602,580,144 bytes, +0.22% |

NOTE: Residency is measured with extra runtime args: `-i0 -h` which effectively

turn all GCs into major GCs, and do GC more often.

|     | GHC HEAD                   | This patch                   | Diff                       |

|-----|----------------------------|------------------------------|----------------------------|

| -O0 | 410,284,000 (910 samples)  | 411,745,008 (906 samples)    | +1,461,008 bytes, +0.35%   |

| -O1 | 928,580,856 (2109 samples) | 943,506,552 (2103 samples)   | +14,925,696 bytes, +1.60%  |

| -O2 | 993,951,352 (2549 samples) | 1,010,156,328 (2545 samples) | +16,204,9760 bytes, +1.63% |

NoFib results:

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

        Program           Size    Allocs    Instrs     Reads    Writes

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

             CS           0.0%      0.0%     +0.0%     +0.0%     +0.0%

            CSD           0.0%      0.0%      0.0%     +0.0%     +0.0%

             FS           0.0%      0.0%     +0.0%     +0.0%     +0.0%

              S           0.0%      0.0%     +0.0%     +0.0%     +0.0%

             VS           0.0%      0.0%     +0.0%     +0.0%     +0.0%

            VSD           0.0%      0.0%     +0.0%     +0.0%     +0.1%

            VSM           0.0%      0.0%     +0.0%     +0.0%     +0.0%

           anna           0.0%      0.0%     -0.3%     -0.8%     -0.0%

           ansi           0.0%      0.0%     -0.0%     -0.0%      0.0%

           atom           0.0%      0.0%     -0.0%     -0.0%      0.0%

         awards           0.0%      0.0%     -0.1%     -0.3%      0.0%

         banner           0.0%      0.0%     -0.0%     -0.0%     -0.0%

     bernouilli           0.0%      0.0%     -0.0%     -0.0%     -0.0%

   binary-trees           0.0%      0.0%     -0.0%     -0.0%     +0.0%

          boyer           0.0%      0.0%     -0.0%     -0.0%      0.0%

         boyer2           0.0%      0.0%     -0.0%     -0.0%      0.0%

           bspt           0.0%      0.0%     -0.0%     -0.2%      0.0%

      cacheprof           0.0%      0.0%     -0.1%     -0.4%     +0.0%

       calendar           0.0%      0.0%     -0.0%     -0.0%      0.0%

       cichelli           0.0%      0.0%     -0.9%     -2.4%      0.0%

        circsim           0.0%      0.0%     -0.0%     -0.0%      0.0%

       clausify           0.0%      0.0%     -0.1%     -0.3%      0.0%

  comp_lab_zift           0.0%      0.0%     -0.0%     -0.0%     +0.0%

       compress           0.0%      0.0%     -0.0%     -0.0%     -0.0%

      compress2           0.0%      0.0%     -0.0%     -0.0%      0.0%

    constraints           0.0%      0.0%     -0.1%     -0.2%     -0.0%

   cryptarithm1           0.0%      0.0%     -0.0%     -0.0%      0.0%

   cryptarithm2           0.0%      0.0%     -1.4%     -4.1%     -0.0%

            cse           0.0%      0.0%     -0.0%     -0.0%     -0.0%

   digits-of-e1           0.0%      0.0%     -0.0%     -0.0%     -0.0%

   digits-of-e2           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         dom-lt           0.0%      0.0%     -0.1%     -0.2%      0.0%

          eliza           0.0%      0.0%     -0.5%     -1.5%      0.0%

          event           0.0%      0.0%     -0.0%     -0.0%     -0.0%

    exact-reals           0.0%      0.0%     -0.1%     -0.3%     +0.0%

         exp3_8           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         expert           0.0%      0.0%     -0.3%     -1.0%     -0.0%

 fannkuch-redux           0.0%      0.0%     +0.0%     +0.0%     +0.0%

          fasta           0.0%      0.0%     -0.0%     -0.0%     +0.0%

            fem           0.0%      0.0%     -0.0%     -0.0%      0.0%

            fft           0.0%      0.0%     -0.0%     -0.0%      0.0%

           fft2           0.0%      0.0%     -0.0%     -0.0%      0.0%

       fibheaps           0.0%      0.0%     -0.0%     -0.0%     +0.0%

           fish           0.0%      0.0%      0.0%     -0.0%     +0.0%

          fluid           0.0%      0.0%     -0.4%     -1.2%     +0.0%

         fulsom           0.0%      0.0%     -0.0%     -0.0%      0.0%

         gamteb           0.0%      0.0%     -0.1%     -0.3%      0.0%

            gcd           0.0%      0.0%     -0.0%     -0.0%      0.0%

    gen_regexps           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         genfft           0.0%      0.0%     -0.0%     -0.0%      0.0%

             gg           0.0%      0.0%     -0.0%     -0.0%     +0.0%

           grep           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         hidden           0.0%      0.0%     -0.1%     -0.4%     -0.0%

            hpg           0.0%      0.0%     -0.2%     -0.5%     +0.0%

            ida           0.0%      0.0%     -0.0%     -0.0%     +0.0%

          infer           0.0%      0.0%     -0.3%     -0.8%     -0.0%

        integer           0.0%      0.0%     -0.0%     -0.0%     +0.0%

      integrate           0.0%      0.0%     -0.0%     -0.0%      0.0%

   k-nucleotide           0.0%      0.0%     -0.0%     -0.0%     +0.0%

          kahan           0.0%      0.0%     -0.0%     -0.0%     +0.0%

        knights           0.0%      0.0%     -2.2%     -5.4%      0.0%

         lambda           0.0%      0.0%     -0.6%     -1.8%      0.0%

     last-piece           0.0%      0.0%     -0.0%     -0.0%      0.0%

           lcss           0.0%      0.0%     -0.0%     -0.1%      0.0%

           life           0.0%      0.0%     -0.0%     -0.1%      0.0%

           lift           0.0%      0.0%     -0.2%     -0.6%     +0.0%

         linear           0.0%      0.0%     -0.0%     -0.0%     -0.0%

      listcompr           0.0%      0.0%     -0.0%     -0.0%      0.0%

       listcopy           0.0%      0.0%     -0.0%     -0.0%      0.0%

       maillist           0.0%      0.0%     -0.1%     -0.3%     +0.0%

         mandel           0.0%      0.0%     -0.0%     -0.0%      0.0%

        mandel2           0.0%      0.0%     -0.0%     -0.0%     -0.0%

           mate          +0.0%      0.0%     -0.0%     -0.0%     -0.0%

        minimax           0.0%      0.0%     -0.2%     -1.0%      0.0%

        mkhprog           0.0%      0.0%     -0.1%     -0.2%     -0.0%

     multiplier           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         n-body           0.0%      0.0%     -0.0%     -0.0%     +0.0%

       nucleic2           0.0%      0.0%     -0.1%     -0.2%      0.0%

           para           0.0%      0.0%     -0.0%     -0.0%     -0.0%

      paraffins           0.0%      0.0%     -0.0%     -0.0%      0.0%

         parser           0.0%      0.0%     -0.2%     -0.7%      0.0%

        parstof           0.0%      0.0%     -0.0%     -0.0%     +0.0%

            pic           0.0%      0.0%     -0.0%     -0.0%      0.0%

       pidigits           0.0%      0.0%     +0.0%     +0.0%     +0.0%

          power           0.0%      0.0%     -0.2%     -0.6%     +0.0%

         pretty           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         primes           0.0%      0.0%     -0.0%     -0.0%      0.0%

      primetest           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         prolog           0.0%      0.0%     -0.3%     -1.1%      0.0%

         puzzle           0.0%      0.0%     -0.0%     -0.0%      0.0%

         queens           0.0%      0.0%     -0.0%     -0.0%     +0.0%

        reptile           0.0%      0.0%     -0.0%     -0.0%      0.0%

reverse-complem           0.0%      0.0%     -0.0%     -0.0%     +0.0%

        rewrite           0.0%      0.0%     -0.7%     -2.5%     -0.0%

           rfib           0.0%      0.0%     -0.0%     -0.0%      0.0%

            rsa           0.0%      0.0%     -0.0%     -0.0%      0.0%

            scc           0.0%      0.0%     -0.1%     -0.2%     -0.0%

          sched           0.0%      0.0%     -0.0%     -0.0%     -0.0%

            scs           0.0%      0.0%     -1.0%     -2.6%     +0.0%

         simple           0.0%      0.0%     +0.0%     -0.0%     +0.0%

          solid           0.0%      0.0%     -0.0%     -0.0%      0.0%

        sorting           0.0%      0.0%     -0.6%     -1.6%      0.0%

  spectral-norm           0.0%      0.0%     +0.0%      0.0%     +0.0%

         sphere           0.0%      0.0%     -0.0%     -0.0%     -0.0%

         symalg           0.0%      0.0%     -0.0%     -0.0%     +0.0%

            tak           0.0%      0.0%     -0.0%     -0.0%      0.0%

      transform           0.0%      0.0%     -0.0%     -0.0%      0.0%

       treejoin           0.0%      0.0%     -0.0%     -0.0%      0.0%

      typecheck           0.0%      0.0%     -0.0%     -0.0%     +0.0%

        veritas          +0.0%      0.0%     -0.2%     -0.4%     +0.0%

           wang           0.0%      0.0%     -0.0%     -0.0%      0.0%

      wave4main           0.0%      0.0%     -0.0%     -0.0%     -0.0%

   wheel-sieve1           0.0%      0.0%     -0.0%     -0.0%     -0.0%

   wheel-sieve2           0.0%      0.0%     -0.0%     -0.0%     +0.0%

           x2n1           0.0%      0.0%     -0.0%     -0.0%     -0.0%

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

            Min           0.0%      0.0%     -2.2%     -5.4%     -0.0%

            Max          +0.0%      0.0%     +0.0%     +0.0%     +0.1%

 Geometric Mean          -0.0%     -0.0%     -0.1%     -0.3%     +0.0%

Metric increases micro benchmarks tracked in #17686:

Metric Increase:

    T12150

    T12234

    T12425

    T13035

    T5837

    T6048

    T9233

Co-authored-by: Andreas Klebinger <klebinger.andreas@gmx.at>

</pre>

</li>

<li>

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

<div>

<span>by Shayne Fletcher</span>

<i>at 2020-06-10T04:15:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Give Language a Bounded instance

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9454511b0bdfcd79a1899d7f24bf65a3eb0d06e3">9454511b</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-10T04:17:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Optimisation in Unique.Supply

This patch switches on -fno-state-hack in GHC.Types.Unique.Supply.

It turned out that my fixes for #18078 (coercion floating) changed the

optimisation pathway for mkSplitUniqSupply in such a way that we had

an extra allocation inside the inner loop.  Adding -fno-state-hack

fixed that -- and indeed the loop in mkSplitUniqSupply is a classic

example of the way in which -fno-state-hack can be bad; see #18238.

Moreover, the new code is better than the old.  They allocate

the same, but the old code ends up with a partial application.

The net effect is that the test

    perf/should_run/UniqLoop

runs 20% faster!   From 2.5s down to 2.0s.  The allocation numbers

are the same -- but elapsed time falls. Good!

The bad thing about this is that it's terribly delicate.  But

at least it's a good example of such delicacy in action.

There is a long Note [Optimising the unique supply] which now

explains all this.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-10T04:17:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement cast worker/wrapper properly

The cast worker/wrapper transformation transforms

   x = e |> co

into

   y = e

   x = y |> co

This is done by the simplifier, but we were being

careless about transferring IdInfo from x to y,

and about what to do if x is a NOINLNE function.

This resulted in a series of bugs:

     #17673, #18093, #18078.

This patch fixes all that:

* Main change is in GHC.Core.Opt.Simplify, and

  the new prepareBinding function, which does this

  cast worker/wrapper transform.

  See Note [Cast worker/wrappers].

* There is quite a bit of refactoring around

  prepareRhs, makeTrivial etc.  It's nicer now.

* Some wrappers from strictness and cast w/w, notably those for

  a function with a NOINLINE, should inline very late. There

  wasn't really a mechanism for that, which was an existing bug

  really; so I invented a new finalPhase = Phase (-1).  It's used

  for all simplifier runs after the user-visible phase 2,1,0 have

  run.  (No new runs of the simplifier are introduced thereby.)

  See new Note [Compiler phases] in GHC.Types.Basic;

  the main changes are in GHC.Core.Opt.Driver

* Doing this made me trip over two places where the AnonArgFlag on a

  FunTy was being lost so we could end up with (Num a -> ty)

  rather than (Num a => ty)

    - In coercionLKind/coercionRKind

    - In contHoleType in the Simplifier

  I fixed the former by defining mkFunctionType and using it in

  coercionLKind/RKind.

  I could have done the same for the latter, but the information

  is almost to hand.  So I fixed the latter by

    - adding sc_hole_ty to ApplyToVal (like ApplyToTy),

    - adding as_hole_ty to ValArg (like TyArg)

    - adding sc_fun_ty to StrictArg

  Turned out I could then remove ai_type from ArgInfo.  This is

  just moving the deck chairs around, but it worked out nicely.

  See the new Note [AnonArgFlag] in GHC.Types.Var

* When looking at the 'arity decrease' thing (#18093) I discovered

  that stable unfoldings had a much lower arity than the actual

  optimised function.  That's what led to the arity-decrease

  message.  Simple solution: eta-expand.

  It's described in Note [Eta-expand stable unfoldings]

  in GHC.Core.Opt.Simplify

* I also discovered that unsafeCoerce wasn't being inlined if

  the context was boring.  So (\x. f (unsafeCoerce x)) would

  create a thunk -- yikes!  I fixed that by making inlineBoringOK

  a bit cleverer: see Note [Inline unsafeCoerce] in GHC.Core.Unfold.

  I also found that unsafeCoerceName was unused, so I removed it.

I made a test case for #18078, and a very similar one for #17673.

The net effect of all this on nofib is very modest, but positive:

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

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

           anna          -0.4%     -0.1%     -3.1%     -3.1%      0.0%

 fannkuch-redux          -0.4%     -0.3%     -0.1%     -0.1%      0.0%

       maillist          -0.4%     -0.1%     -7.8%     -1.0%    -14.3%

      primetest          -0.4%    -15.6%     -7.1%     -6.6%      0.0%

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

            Min          -0.9%    -15.6%    -13.3%    -14.2%    -14.3%

            Max          -0.3%      0.0%    +12.1%    +12.4%      0.0%

 Geometric Mean          -0.4%     -0.2%     -2.3%     -2.2%     -0.1%

All following metric decreases are compile-time allocation decreases

between -1% and -3%:

Metric Decrease:

  T5631

  T13701

  T14697

  T15164

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32fd37f5e1e6dc6e3b664ae41e0041ed8a19ae21">32fd37f5</a></strong>

<div>

<span>by Luke Lau</span>

<i>at 2020-06-10T04:17:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix lookupGlobalOccRn_maybe sometimes reporting an error

In some cases it was possible for lookupGlobalOccRn_maybe to return an

error, when it should be returning a Nothing. If it called

lookupExactOcc_either when there were no matching GlobalRdrElts in the

otherwise case, it would return an error message. This could be caused

when lookupThName_maybe in Template Haskell was looking in different

namespaces (thRdrNameGuesses), guessing different namespaces that the

name wasn't guaranteed to be found in.

However, by addressing this some more accurate errors were being lost in

the conversion to Maybes. So some of the lookup* functions have been

shuffled about so that errors should always be ignored in

lookup*_maybes, and propagated otherwise.

This fixes #18263

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-06-10T04:17:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Initialize the allocation counter in GHCi to 0 (Fixes #16012)

According to the documentation for the function `getAllocationCounter` in

[System.Mem](http://hackage.haskell.org/package/base-4.14.0.0/docs/System-Mem.html)

initialize the allocationCounter also in GHCi to 0.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-10T04:17:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">test: fix conc038

We had spurious failures of conc038 test on CI with stdout:

```

 newThread started

-mainThread

-Haskell: 2

 newThread back again

+mainThread

 1 sec later

 shutting down

+Haskell: 2

```

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-06-11T10:37:38+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Release Notes: Add news from the pattern-match checker [skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3445b9652671280920755ee3d2b49780eeb3a991">3445b965</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Only test T16190 with the NCG

T16190 is meant to test a NCG feature. It has already caused spurious

failures in other MRs (e.g. !2165) when LLVM is used.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2517a51c0f949c1021de9f7c16f67345c6ab78a9">2517a51c</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags refactoring VIII (#17957)

* Remove several uses of `sdocWithDynFlags`, especially in GHC.Llvm.*

* Add LlvmOpts datatype to store Llvm backend options

* Remove Outputable instances (for LlvmVar, LlvmLit, LlvmStatic and

  Llvm.MetaExpr) which require LlvmOpts.

* Rename ppMetaExpr into ppMetaAnnotExpr (pprMetaExpr is now used in place of `ppr :: MetaExpr -> SDoc`)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/72d086106d49bc18277f3a066e671e87e9b37a1b">72d08610</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

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

* rename thisPackage into homeUnit

* document and refactor several Backpack things

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename unsafeGetUnitInfo into unsafeLookupUnit

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add allowVirtualUnits field in PackageState

Instead of always querying DynFlags to know whether we are allowed to

use virtual units (i.e. instantiated on-the-fly, cf Note [About units]

in GHC.Unit), we store it once for all in

`PackageState.allowVirtualUnits`.

This avoids using DynFlags too much (cf #17957) and is preliminary work

for #14335.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enhance UnitId use

* use UnitId instead of String to identify wired-in units

* use UnitId instead of Unit in the backend (Unit are only use by

  Backpack to produce type-checked interfaces, not real code)

* rename lookup functions for consistency

* documentation

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove LinkerUnitId type alias

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

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

* Remove WiredInUnitId and WiredUnitId type aliases

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document and refactor `mkUnit` and `mkUnitInfoMap`

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove PreloadUnitId type alias

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename listUnitInfoMap into listUnitInfo

There is no Map involved

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename Package into Unit

The terminology changed over time and now package databases contain

"units" (there can be several units compiled from a single Cabal

package: one per-component, one for each option set, one per

instantiation, etc.). We should try to be consistent internally and use

"units": that's what this renaming does. Maybe one day we'll fix the UI

too (e.g. replace -package-id with -unit-id, we already have

-this-unit-id and ghc-pkg has -unit-id...) but it's not done in this

patch.

* rename getPkgFrameworkOpts into getUnitFrameworkOpts

* rename UnitInfoMap into ClosureUnitInfoMap

* rename InstalledPackageIndex into UnitInfoMap

* rename UnusablePackages into UnusableUnits

* rename PackagePrecedenceIndex into UnitPrecedenceMap

* rename PackageDatabase into UnitDatabase

* rename pkgDatabase into unitDatabases

* rename pkgState into unitState

* rename initPackages into initUnits

* rename renamePackage into renameUnitInfo

* rename UnusablePackageReason into UnusableUnitReason

* rename getPackage* into getUnit*

* etc.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/202728e529f2faa88731b9f4b34b2ac567eb7c95">202728e5</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make ClosureUnitInfoMap uses UnitInfoMap

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/653d17bdd57ec8ca9b11b19e45860982bd1e7c9e">653d17bd</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename Package into Unit (2)

* rename PackageState into UnitState

* rename findWiredInPackages into findWiredInUnits

* rename lookupModuleInAll[Packages,Units]

* etc.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move dump_mod_map into initUnits

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/598cc1dde543807902fd502b5e2f8050ebac1fa5">598cc1dd</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move wiring of homeUnitInstantiations outside of mkUnitState

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/437265eb26b45a2de3ac537b6bc9a81986d4f7ae">437265eb</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid timing module map dump in initUnits

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9400aa934880695b83201e192998de2576cfdf92">9400aa93</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove preload parameter of mkUnitState

* Remove preload parameter (unused)

* Don't explicitly return preloaded units: redundant because already

  returned as "preloadUnits" field of UnitState

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/266bc3d9c3735620598ab18ff6ac9c44134cbbff">266bc3d9</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: refactor unwireUnit

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: remove useless add_package parameter

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/36e1daf0a604d98a34d9a066a01dd4f5439b4aca">36e1daf0</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: make listVisibleModuleNames take a UnitState

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5226da37845ae82bff0e3e6b16be7453e3d9370d">5226da37</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/42c054f6cd7a9890c3e9d2d0c444252abe08a8d5">42c054f6</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: reportCycles, reportUnusable

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8408d521a67e2af4012d886d6a7e2af02ce42add">8408d521</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add UnitConfig datatype

Avoid directly querying flags from DynFlags to build the UnitState.

Instead go via UnitConfig so that we could reuse this to make another

UnitState for plugins.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move distrustAll into mkUnitState

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/28d804e1e12a6be9bcd94b4667e27ba73beade38">28d804e1</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Create helper upd_wired_in_home_instantiations

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Put database cache in UnitConfig

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't return preload units when we set DyNFlags

Preload units can be retrieved in UnitState when needed (i.e. in GHCi)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCGConfig: remove useless ncgUnitId field

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Doc: fix some comments

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/456e17f035238984e487870fe8007f5fb5f726cf">456e17f0</a></strong>

<div>

<span>by Sylvain Henry</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump haddock submodule and allow metric decrease

Metric Decrease:

    T12150

    T12234

    T5837

Metric Increase:

    T16190

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/429539025450757e30124fa9ee33206deeb951a2">42953902</a></strong>

<div>

<span>by Simon Peyton Jones</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Trim the demand for recursive product types

Ticket #18304 showed that we need to be very careful

when exploring the demand (esp usage demand) on recursive

product types.

This patch solves the problem by trimming the demand on such types --

in effect, a form of "widening".

See the Note [Trimming a demand to a type] in DmdAnal, which explains

how I did this by piggy-backing on an existing mechansim for trimming

demands becuase of GADTs.  The significant payload of this patch is

very small indeed:

* Make GHC.Core.Opt.WorkWrap.Utils.typeShape use RecTcChecker to

  avoid looking through recursive types.

But on the way

* I found that ae_rec_tc was entirely inoperative and did nothing.

  So I removed it altogether from DmdAnal.

* I moved some code around in DmdAnal and Demand.

  (There are no actual changes in dmdFix.)

* I changed the API of DmsAnal.dmdAnalRhsLetDown to return

  a StrictSig rather than a decorated Id

* I removed the dead function peelTsFuns from Demand

Performance effects:

Nofib: 0.0% changes.  Not surprising, because they don't

       use recursive products

Perf tests

T12227:

  1% increase in compiler allocation, becuase $cto gets w/w'd.

  It did not w/w before because it takes a deeply nested

  argument, so the worker gets too many args, so we abandon w/w

  altogether (see GHC.Core.Opt.WorkWrap.Utils.isWorkerSmallEnough)

  With this patch we trim the demands.  That is not strictly

  necessary (since these Generic type constructors are like

  tuples -- they can't cause a loop) but the net result is that

  we now w/w $cto which is fine.

UniqLoop:

  16% decrease in /runtime/ allocation. The UniqSupply is a

  recursive product, so currently we abandon all strictness on

  'churn'.  With this patch 'churn' gets useful strictness, and

  we w/w it.  Hooray

Metric Decrease:

    UniqLoop

Metric Increase:

    T12227

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/87d504f475471c61305b29578da2656f9ff9653e">87d504f4</a></strong>

<div>

<span>by Viktor Dukhovni</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add introductory prose for Data.Traversable

</pre>

</li>

<li>

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

<div>

<span>by Oleg Grenrus</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix #12073: Add MonadFix Q instance

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/220c2d34a34727d696cc4b44a1b87aba83231ce4">220c2d34</a></strong>

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Increase size of T12150

As noted in #18319, this test was previously very fragile. Increase its

size to make it more likely that its fails with its newly-increased

acceptance threshold.

Metric Increase:

    T12150

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-13T04:59:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Always push perf notes

Previously we ci.sh would run with `set -e` implying that we wouldn't

push perf notes if the testsuite were to fail, even if it *only* failed

due to perf notes. This rendered the whole performance testing story

quite fragile as a single regressing commit would cause every successive

commit to fail since a new baseline would not be uploaded.

Fix this by ensuring that we always push performance notes.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-13T15:10:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Eliminate redundant push of CI metrics

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-13T15:58:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use HsForAllTelescope to avoid inferred, visible foralls

Currently, `HsForAllTy` permits the combination of `ForallVis` and

`Inferred`, but you can't actually typecheck code that uses it

(e.g., `forall {a} ->`). This patch refactors `HsForAllTy` to use a

new `HsForAllTelescope` data type that makes a type-level distinction

between visible and invisible `forall`s such that visible `forall`s

do not track `Specificity`. That part of the patch is actually quite

small; the rest is simply changing consumers of `HsType` to

accommodate this new type.

Fixes #18235. Bumps the `haddock` submodule.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-06-14T09:07:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add Atomic Exchange PrimOp and implement Atomic Ptr exchanges.

The initial version was rewritten by Tamar Christina.

It was rewritten in large parts by Andreas Klebinger.

Co-authored-by: Andreas Klebinger <klebinger.andreas@gmx.at>

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">codeGen: Don't discard live case binders in unsafeEqualityProof logic

Previously CoreToStg would unconditionally discard cases of the form:

    case unsafeEqualityProof of wild { _ -> rhs }

and rather replace the whole thing with `rhs`. However, in some cases

(see #18227) the case binder is still live, resulting in unbound

occurrences in `rhs`. Fix this by only discarding the case if the case

binder is dead.

Fixes #18227.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:23-04:00</i>

</div>

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

T18227A is the original issue which gave rise to the ticket and depends

upon bytestring. T18227B is a minimized reproducer.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fix rts include and library paths

Fixes two bugs:

 * (?) and (<>) associated in a surprising way

 * We neglected to include libdw paths in the rts configure flags

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-14T15:35:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Drop redundant GHC arguments

Cabal should already be passing this arguments to GHC.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01f7052cc182c0ced85522dc775ebc490bf094ce">01f7052c</a></strong>

<div>

<span>by Peter Trommler</span>

<i>at 2020-06-14T15:36:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">FFI: Fix pass small ints in foreign call wrappers

The Haskell calling convention requires integer parameters smaller

than wordsize to be promoted to wordsize (where the upper bits are

don't care). To access such small integer parameter read a word from

the parameter array and then cast that word to the small integer

target type.

Fixes #15933

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/502647f7583be626319482adf4ea3d905db0006d">502647f7</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-14T15:37:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix "ndecreasingIndentation" in manual (#18116)

</pre>

</li>

<li>

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

<div>

<span>by Simon Jakobi</span>

<i>at 2020-06-15T13:10:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use foldl' in unionManyUniqDSets

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/761dcb84cd4c50c6fbb361eb26fb429af87392a3">761dcb84</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-06-15T13:10:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Load .lo as well.

Some archives contain so called linker objects, with the affectionate

.lo suffic.  For example the musl libc.a will come in that form.  We

still want to load those objects, hence we should not discard them and

look for .lo as well.  Ultimately we might want to fix this proerly by

looking at the file magic.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-06-15T13:11:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">User's Guide: KnownNat evidence is Natural

This bit of documentation got outdated after commit

1fcede43d2b30f33b7505e25eb6b1f321be0407f

</pre>

</li>

<li>

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

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos and formatting in user guide

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/56a9e95fd6c2f213d676c9a2bd0a6cf93c531dbb">56a9e95f</a></strong>

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-16T20:36:38+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename TcHoleErrors to GHC.Tc.Errors.Hole

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-06-17T15:31:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Build with threaded runtime if available

See #16873.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0639dc10e214280a90dd6b75ce86cf43d1eb2286">0639dc10</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T15:31:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">T16190: only measure bytes_allocated

Just adding `{-# LANGUAGE BangPatterns #-}` makes the two other metrics

fluctuate by 13%.

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-06-17T15:32:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: fix formatting in users guide

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T15:33:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move CLabel assertions into smart constructors (#17957)

It avoids using DynFlags in the Outputable instance of Clabel to check

assertions at pretty-printing time.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-17T15:43:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Bump to 4.15.0.0

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-17T15:43:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Use grep -q instead of --quiet

The latter is apparently not supported by busybox.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-17T16:21:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types (#15981)

This is the first step towards implementation of the linear types proposal

(https://github.com/ghc-proposals/ghc-proposals/pull/111).

It features

* A language extension -XLinearTypes

* Syntax for linear functions in the surface language

* Linearity checking in Core Lint, enabled with -dlinear-core-lint

* Core-to-core passes are mostly compatible with linearity

* Fields in a data type can be linear or unrestricted; linear fields

  have multiplicity-polymorphic constructors.

  If -XLinearTypes is disabled, the GADT syntax defaults to linear fields

The following items are not yet supported:

* a # m -> b syntax (only prefix FUN is supported for now)

* Full multiplicity inference (multiplicities are really only checked)

* Decent linearity error messages

* Linear let, where, and case expressions in the surface language

  (each of these currently introduce the unrestricted variant)

* Multiplicity-parametric fields

* Syntax for annotating lambda-bound or let-bound with a multiplicity

* Syntax for non-linear/multiple-field-multiplicity records

* Linear projections for records with a single linear field

* Linear pattern synonyms

* Multiplicity coercions (test LinearPolyType)

A high-level description can be found at

https://ghc.haskell.org/trac/ghc/wiki/LinearTypes/Implementation

Following the link above you will find a description of the changes made to Core.

This commit has been authored by

* Richard Eisenberg

* Krzysztof Gogolewski

* Matthew Pickering

* Arnaud Spiwack

With contributions from:

* Mark Barbone

* Alexander Vershilov

Updates haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Various performance improvements

This implements several general performance improvements to GHC,

to offset the effect of the linear types change.

General optimisations:

- Add a `coreFullView` function which iterates `coreView` on the

  head. This avoids making function recursive solely because the

  iterate `coreView` themselves. As a consequence, this functions can

  be inlined, and trigger case-of-known constructor (_e.g._

  `kindRep_maybe`, `isLiftedRuntimeRep`, `isMultiplicityTy`,

  `getTyVar_maybe`, `splitAppTy_maybe`, `splitFunType_maybe`,

  `tyConAppTyCon_maybe`). The common pattern about all these functions

  is that they are almost always used as views, and immediately

  consumed by a case expression. This commit also mark them asx `INLINE`.

- In `subst_ty` add a special case for nullary `TyConApp`, which avoid

  allocations altogether.

- Use `mkTyConApp` in `subst_ty` for the general `TyConApp`. This

  required quite a bit of module shuffling.

  case. `myTyConApp` enforces crucial sharing, which was lost during

  substitution. See also !2952 .

- Make `subst_ty` stricter.

- In `eqType` (specifically, in `nonDetCmpType`), add a special case,

  tested first, for the very common case of nullary `TyConApp`.

  `nonDetCmpType` has been made `INLINE` otherwise it is actually a

  regression. This is similar to the optimisations in !2952.

Linear-type specific optimisations:

- Use `tyConAppTyCon_maybe` instead of the more complex `eqType` in

  the definition of the pattern synonyms `One` and `Many`.

- Break the `hs-boot` cycles between `Multiplicity.hs` and `Type.hs`:

  `Multiplicity` now import `Type` normally, rather than from the

  `hs-boot`. This way `tyConAppTyCon_maybe` can inline properly in the

  `One` and `Many` pattern synonyms.

- Make `updateIdTypeAndMult` strict in its type and multiplicity

- The `scaleIdBy` gets a specialised definition rather than being an

  alias to `scaleVarBy`

- `splitFunTy_maybe` is given the type `Type -> Maybe (Mult, Type,

  Type)` instead of `Type -> Maybe (Scaled Type, Type)`

- Remove the `MultMul` pattern synonym in favour of a view `isMultMul`

  because pattern synonyms appear not to inline well.

- in `eqType`, in a `FunTy`, compare multiplicities last: they are

  almost always both `Many`, so it helps failing faster.

- Cache `manyDataConTy` in `mkTyConApp`, to make sure that all the

  instances of `TyConApp ManyDataConTy []` are physically the same.

This commit has been authored by

* Richard Eisenberg

* Krzysztof Gogolewski

* Arnaud Spiwack

Metric Decrease:

    haddock.base

    T12227

    T12545

    T12990

    T1969

    T3064

    T5030

    T9872b

Metric Increase:

    haddock.base

    haddock.Cabal

    haddock.compiler

    T12150

    T12234

    T12425

    T12707

    T13035

    T13056

    T15164

    T16190

    T18304

    T1969

    T3064

    T3294

    T5631

    T5642

    T5837

    T6048

    T9020

    T9233

    T9675

    T9872a

    T9961

    WWRec

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57db91d8ee501c7cf176c4bb1e2101d3092fd0f6">57db91d8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

integer-simple uses lists of words (`[Word]`) to represent big numbers

instead of ByteArray#:

   * it is less efficient than the newer ghc-bignum native backend

   * it isn't compatible with the big number representation that is now

     shared by all the ghc-bignum backends (based on the one that was

     used only in integer-gmp before).

As a consequence, we simply drop integer-simple

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bignum library

ghc-bignum is a newer package that aims to replace the legacy

integer-simple and integer-gmp packages.

* it supports several backends. In particular GMP is still supported and

  most of the code from integer-gmp has been merged in the "gmp"

  backend.

* the pure Haskell "native" backend is new and is much faster than the

  previous pure Haskell implementation provided by integer-simple

* new backends are easier to write because they only have to provide a

  few well defined functions. All the other code is common to all

  backends. In particular they all share the efficient small/big number

  distinction previously used only in integer-gmp.

* backends can all be tested against the "native" backend with a simple

  Cabal flag. Backends are only allowed to differ in performance, their

  results should be the same.

* Add `integer-gmp` compat package: provide some pattern synonyms and

  function aliases for those in `ghc-bignum`. It is intended to avoid

  breaking packages that depend on `integer-gmp` internals.

Update submodules: text, bytestring

Metric Decrease:

    Conversions

    ManyAlternatives

    ManyConstructors

    Naperian

    T10359

    T10547

    T10678

    T12150

    T12227

    T12234

    T12425

    T13035

    T13719

    T14936

    T1969

    T4801

    T4830

    T5237

    T5549

    T5837

    T8766

    T9020

    parsing001

    space_leak_001

    T16190

    haddock.base

On ARM and i386, T17499 regresses (+6% > 5%).

On x86_64 unregistered, T13701 sometimes regresses (+2.2% > 2%).

Metric Increase:

    T17499

    T13701

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/96aa57878fd6e6a7b92e841a0df8b5255a559c97">96aa5787</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

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

Thanks to ghc-bignum, the compiler can be simplified:

* Types and constructors of Integer and Natural can be wired-in. It

  means that we don't have to query them from interfaces. It also means

  that numeric literals don't have to carry their type with them.

* The same code is used whatever ghc-bignum backend is enabled. In

  particular, conversion of bignum literals into final Core expressions

  is now much more straightforward. Bignum closure inspection too.

* GHC itself doesn't depend on any integer-* package anymore

* The `integerLibrary` setting is gone.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update `base` package

* GHC.Natural isn't implemented in `base` anymore. It is provided by

  ghc-bignum in GHC.Num.Natural. It means that we can safely use Natural

  primitives in `base` without fearing issues with built-in rewrite

  rules (cf #15286)

* `base` doesn't conditionally depend on an integer-* package anymore,

  it depends on ghc-bignum

* Some duplicated code in integer-* can now be factored in GHC.Float

* ghc-bignum tries to use a uniform naming convention so most of the

  other changes are renaming

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update `make` based build system

* replace integer-* package selection with ghc-bignum backend selection

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

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

* support detection of slow ghc-bignum backend (to replace the detection

  of integer-simple use). There are still some test cases that the

  native backend doesn't handle efficiently enough.

* remove tests for GMP only functions that have been removed from

  ghc-bignum

* fix test results showing dependent packages (e.g. integer-gmp) or

  showing suggested instances

* fix test using Integer/Natural API or showing internal names

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

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

* support ghc-bignum backend selection in flavours and command-line

* support ghc-bignum "--check" flag (compare results of selected backend

  against results of the native one) in flavours and command-line (e.g.

  pass --bignum=check-gmp" to check the "gmp" backend)

* remove the hack to workaround #15286

* build GMP only when the gmp backend is used

* remove hacks to workaround `text` package flags about integer-*. We

  fix `text` to use ghc-bignum unconditionally in another patch

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-17T16:22:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump bytestring and text submodules

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-06-18T23:03:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: mention -hiedir in docs for -outputdir

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/729bcb02716593ae46d7baecce4776b3f353e3f7">729bcb02</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:04:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix build on Mac OS Catalina (#17798)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/95e18292731cd799e024976f11c18fdf34bcb777">95e18292</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-06-18T23:04:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Relax allocation threshold for T12150.

This test performs little work, so the most minor allocation

changes often cause the test to fail.

Increasing the threshold to 2% should help with this.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-06-18T23:05:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Bump pinned cabal.project to an existent index-state

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/08c1cb0f30770acbf366423f085f8ef92f7f6a06">08c1cb0f</a></strong>

<div>

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

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix uninitialized field read in Linker.c

Valgrind report of the bug when running the test `linker_unload`:

    ==29666== Conditional jump or move depends on uninitialised value(s)

    ==29666==    at 0x369C5B4: setOcInitialStatus (Linker.c:1305)

    ==29666==    by 0x369C6C5: mkOc (Linker.c:1347)

    ==29666==    by 0x36C027A: loadArchive_ (LoadArchive.c:522)

    ==29666==    by 0x36C0600: loadArchive (LoadArchive.c:626)

    ==29666==    by 0x2C144CD: ??? (in /home/omer/haskell/ghc_2/testsuite/tests/rts/linker/linker_unload.run/linker_unload)

    ==29666==

    ==29666== Conditional jump or move depends on uninitialised value(s)

    ==29666==    at 0x369C5B4: setOcInitialStatus (Linker.c:1305)

    ==29666==    by 0x369C6C5: mkOc (Linker.c:1347)

    ==29666==    by 0x369C9F6: preloadObjectFile (Linker.c:1507)

    ==29666==    by 0x369CA8D: loadObj_ (Linker.c:1536)

    ==29666==    by 0x369CB17: loadObj (Linker.c:1557)

    ==29666==    by 0x3866BC: main (linker_unload.c:33)

The problem is `mkOc` allocates a new `ObjectCode` and calls

`setOcInitialStatus` without initializing the `status` field.

`setOcInitialStatus` reads the field as first thing:

    static void setOcInitialStatus(ObjectCode* oc) {

        if (oc->status == OBJECT_DONT_RESOLVE)

          return;

        if (oc->archiveMemberName == NULL) {

            oc->status = OBJECT_NEEDED;

        } else {

            oc->status = OBJECT_LOADED;

        }

    }

`setOcInitialStatus` is unsed in two places for two different purposes:

in `mkOc` where we don't have the `status` field initialized yet (`mkOc`

is supposed to initialize it), and `loadOc` where we do have `status`

field initialized and we want to update it. Instead of splitting the

function into two functions which are both called just once I inline the

functions in the use sites and remove it.

Fixes #18342

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-06-18T23:07:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix windows bootstrap due to linker changes

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:07:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: store default depth in SDocContext (#17957)

It avoids having to use DynFlags to reach for pprUserLength.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-18T23:08:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move tablesNextToCode field into Platform

tablesNextToCode is a platform setting and doesn't belong into DynFlags

(#17957). Doing this is also a prerequisite to fix #14335 where we deal

with two platforms (target and host) that may have different platform

settings.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/809caedffe489931efa8c96a60eaed6d7ff739b9">809caedf</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-06-23T22:47:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Switch from HscSource to IsBootInterface for module lookup in GhcMake

We look up modules by their name, and not their contents. There is no

way to separately reference a signature vs regular module; you get what

you get. Only boot files can be referenced indepenently with `import {-#

SOURCE #-}`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7750bd456f32c3e91b9165587fe290122b9c2444">7750bd45</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cmm: introduce SAVE_REGS/RESTORE_REGS

We don't want to save both Fn and Dn register sets on x86-64 as they are

aliased to the same arch register (XMMn).

Moreover, when SAVE_STGREGS was used in conjunction with `jump foo [*]`

which makes a set of Cmm registers alive so that they cover all arch

registers used to pass parameter, we could have Fn, Dn and XMMn alive at

the same time. It made the LLVM code generator choke (see #17920).

Now `SAVE_REGS/RESTORE_REGS` and `jump foo [*]` use the same set of

registers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2636794d1a1d0c4c2666d5afb002b0ba73600f8a">2636794d</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CmmToC: don't add extern decl to parsed Cmm data

Previously, if a .cmm file *not in the RTS* contained something like:

```cmm

section "rodata" { msg : bits8[] "Test\n"; }

```

It would get compiled by CmmToC into:

```c

ERW_(msg);

const char msg[] = "Test\012";

```

and fail with:

```

/tmp/ghc32129_0/ghc_4.hc:5:12: error:

     error: conflicting types for \u2018msg\u2019

     const char msg[] = "Test\012";

                ^~~

In file included from /tmp/ghc32129_0/ghc_4.hc:3:0: error:

/tmp/ghc32129_0/ghc_4.hc:4:6: error:

     note: previous declaration of \u2018msg\u2019 was here

     ERW_(msg);

          ^

/builds/hsyl20/ghc/_build/install/lib/ghc-8.11.0.20200605/lib/../lib/x86_64-linux-ghc-8.11.0.20200605/rts-1.0/include/Stg.h:253:46: error:

     note: in definition of macro \u2018ERW_\u2019

     #define ERW_(X)   extern       StgWordArray (X)

                                                  ^

```

See the rationale for this on https://gitlab.haskell.org/ghc/ghc/-/wikis/commentary/compiler/backends/ppr-c#prototypes

Now we don't generate these extern declarations (ERW_, etc.) for

top-level data. It shouldn't change anything for the RTS (the only place

we use .cmm files) as it is already special cased in

`GHC.Cmm.CLabel.needsCDecl`. And hand-written Cmm can use explicit

extern declarations when needed.

Note that it allows `cgrun069` test to pass with CmmToC (cf #15467).

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: refactor and comment register padding code (#17920)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:48:18-04:00</i>

</div>

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

Metric Decrease:

    T12150

    T12234

</pre>

</li>

<li>

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

<div>

<span>by Xavier Denis</span>

<i>at 2020-06-23T22:48:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix issue #18262 by zonking constraints after solving

Zonk residual constraints in checkForExistence to reveal user type

errors.

Previously when `:instances` was used with instances that have TypeError

constraints the result would look something like:

instance [safe] s0 => Err 'A -- Defined at ../Bug2.hs:8:10

whereas after zonking, `:instances` now sees the `TypeError` and

properly eliminates the constraint from the results.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/181516bcd6f18f22e1df3915bfca0c36524a725b">181516bc</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-23T22:49:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a buglet in Simplify.simplCast

This bug, revealed by #18347, is just a missing update to

sc_hole_ty in simplCast.  I'd missed a code path when I

made the recentchanges in

    commit 6d49d5be904c0c01788fa7aae1b112d5b4dfaf1c

    Author: Simon Peyton Jones <simonpj@microsoft.com>

    Date:   Thu May 21 12:53:35 2020 +0100

    Implement cast worker/wrapper properly

The fix is very easy.

Two other minor changes

* Tidy up in SimpleOpt.simple_opt_expr. In fact I think this is an

  outright bug, introduced in the fix to #18112: we were simplifying

  the same coercion twice *with the same substitution*, which is just

  wrong.  It'd be a hard bug to trigger, so I just fixed it; less code

  too.

* Better debug printing of ApplyToVal

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/625a7f5465d51d054c6930772412bad7d87189c5">625a7f54</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-23T22:50:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Two small tweaks to Coercion.simplifyArgsWorker

These tweaks affect the inner loop of simplifyArgsWorker, which

in turn is called from the flattener in Flatten.hs.  This is

a key perf bottleneck to T9872{a,b,c,d}.

These two small changes have a modest but useful benefit.

No change in functionality whatsoever.

Relates to #18354

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:50:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't use timesInt2# with GHC < 8.11 (fix #18358)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-23T22:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix invalid printf format

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-23T22:52:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing entry to freeNamesItem (#18369)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/03a708ba8e8c323b07d8d2e0115d6eb59987cc02">03a708ba</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-06-25T03:54:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable large address space optimization on windows.

Starting with Win 8.1/Server 2012 windows no longer preallocates

page tables for reserverd memory eagerly, which prevented us from

using this approach in the past.

We also try to allocate the heap high in the memory space.

Hopefully this makes it easier to allocate things in the low

4GB of memory that need to be there. Like jump islands for the

linker.

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-06-25T03:54:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">In `:break ident` allow out of scope and nested identifiers (Fix #3000)

This patch fixes the bug and implements the feature request of #3000.

1. If `Module` is a real module name and `identifier` a name of a

top-level function in `Module` then `:break Module.identifer` works

also for an `identifier` that is out of scope.

2. Extend the syntax for `:break identifier` to:

    :break [ModQual.]topLevelIdent[.nestedIdent]...[.nestedIdent]

`ModQual` is optional and is either the effective name of a module or

the local alias of a qualified import statement.

`topLevelIdent` is the name of a top level function in the module

referenced by `ModQual`.

`nestedIdent` is optional and the name of a function nested in a let or

where clause inside the previously mentioned function `nestedIdent` or

`topLevelIdent`.

If `ModQual` is a module name, then `topLevelIdent` can be any top level

identifier in this module. If `ModQual` is missing or a local alias of a

qualified import, then `topLevelIdent` must be in scope.

Breakpoints can be set on arbitrarily deeply nested functions, but the

whole chain of nested function names must be specified.

3. To support the new functionality rewrite the code to tab complete `:break`.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/30e42652ed895c3ed086e7834be46f93ba1cc61b">30e42652</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">make: Respect XELATEX variable

Previously we simply ignored the XELATEX variable when building

PDF documentation.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian/make: Detect makeindex

Previously we would simply assume that makeindex was available.

Now we correctly detect it in `configure` and respect this conclusion in

hadrian and make.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-25T03:54:40-04:00</i>

</div>

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

GHC.Hs.Extension had

  type GhcPs   = GhcPass 'Parsed

  type GhcRn   = GhcPass 'Renamed

  type GhcTc   = GhcPass 'Typechecked

  type GhcTcId = GhcTc

The last of these, GhcTcId, is a vestige of the past.

This patch expunges it from GHC.

</pre>

</li>

<li>

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

<div>

<span>by Adam Wespiser</span>

<i>at 2020-06-25T03:54:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add examples to Data.Traversable

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/284001d00995c82a1f2b38f696138ad683b5364b">284001d0</a></strong>

<div>

<span>by Oleg Grenrus</span>

<i>at 2020-06-25T03:54:42-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Zubin Duggal</span>

<i>at 2020-06-25T03:54:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export everything from HsToCore.

This lets us reuse these functions in haddock, avoiding synchronization bugs.

Also fixed some divergences with haddock in that file

Updates haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-25T03:54:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up haddock hyperlinks of GHC.* (part1)

This updates haddock comments only.

This patch focuses to update for hyperlinks in GHC API's haddock comments,

because broken links especially discourage newcomers.

This includes the following hierarchies:

  - GHC.Hs.*

  - GHC.Core.*

  - GHC.Stg.*

  - GHC.Cmm.*

  - GHC.Types.*

  - GHC.Data.*

  - GHC.Builtin.*

  - GHC.Parser.*

  - GHC.Driver.*

  - GHC top

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-06-25T03:54:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up haddock hyperlinks of GHC.* (part2)

This updates haddock comments only.

This patch focuses to update for hyperlinks in GHC API's haddock comments,

because broken links especially discourage newcomers.

This includes the following hierarchies:

  - GHC.Iface.*

  - GHC.Llvm.*

  - GHC.Rename.*

  - GHC.Tc.*

  - GHC.HsToCore.*

  - GHC.StgToCmm.*

  - GHC.CmmToAsm.*

  - GHC.Runtime.*

  - GHC.Unit.*

  - GHC.Utils.*

  - GHC.SysTools.*

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67a86b4d4d21954bae7aaddec7617228025a8270">67a86b4d</a></strong>

<div>

<span>by Oleg Grenrus</span>

<i>at 2020-06-25T03:54:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add MonadZip and MonadFix instances for Complex

These instances are taken from

https://hackage.haskell.org/package/linear-1.21/docs/Linear-Instances.html

They are the unique possible, so let they be in `base`.

</pre>

</li>

<li>

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

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-06-25T03:54:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">test suite: add reproducer for #17516

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-06-25T03:54:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable maxBound checks for OverloadedLists (Fixes #18172)

Consider the Literal `[256] :: [Data.Word.Word8]`

When the `OverloadedLists` extension is not active, then the `ol_ext` field

in the `OverLitTc` record that is passed to the function `getIntegralLit`

contains the type `Word8`. This is a simple type, and we can use its

type constructor immediately for the `warnAboutOverflowedLiterals` function.

When the `OverloadedLists` extension is active, then the `ol_ext` field

contains the type family `Item [Word8]`. The function `nomaliseType` is used

to convert it to the needed type `Word8`.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-06-25T03:54:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Hash: Simplify freeing of HashListChunks

While looking at #18348 I noticed that the treatment of HashLists are a

bit more complex than necessary (which lead to some initial confusion on

my part). Specifically, we allocate HashLists in chunks. Each chunk

allocation makes two allocations: one for the chunk itself and one for a

HashListChunk to link together the chunks for the purposes of freeing.

Simplify this (and hopefully make the relationship between these

clearer) but allocating the HashLists and HashListChunk in a single

malloc. This will both make the implementation easier to follow and

reduce C heap fragmentation.

Note that even after this patch we fail to bound the size of the free

HashList pool. However, this is a separate bug.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-25T03:54:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RTS: avoid overflow on 32-bit arch (#18375)

We're now correctly computing allocated bytes on 32-bit arch, so we get

huge increases.

Metric Increase:

    haddock.Cabal

    haddock.base

    haddock.compiler

    space_leak_001

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-06-25T23:06:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHC.Core.Unify: Make UM actions one-shot by default

This MR makes the UM monad in GHC.Core.Unify into a one-shot

monad.  See the long Note [The one-shot state monad trick].

See also #18202 and !3309, which applies this to all Reader/State-like

monads in GHC for compile-time perf improvements. The pattern used

here enables something similar to the state-hack, but is applicable to

user-defined monads, not just `IO`.

Metric Decrease 'runtime/bytes allocated' (test_env='i386-linux-deb9'):

    haddock.Cabal

</pre>

</li>

<li>

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

<div>

<span>by Matthias Pall Gissurarson</span>

<i>at 2020-06-26T17:12:45+00:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement the proposed -XQualifiedDo extension

Co-authored-by: Facundo Domínguez <facundo.dominguez@tweag.io>

QualifiedDo is implemented using the same placeholders for operation names in

the AST that were devised for RebindableSyntax. Whenever the renamer checks

which names to use for do syntax, it first checks if the do block is qualified

(e.g. M.do { stmts }), in which case it searches for qualified names in

the module M.

This allows users to write

    {-# LANGUAGE QualifiedDo #-}

    import qualified SomeModule as M

    f x = M.do           -- desugars to:

      y <- M.return x    -- M.return x M.>>= \y ->

      M.return y         -- M.return y M.>>

      M.return y         -- M.return y

See Note [QualifiedDo] and the users' guide for more details.

Issue #18214

Proposal:

https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0216-qualified-do.rst

Since we change the constructors `ITdo` and `ITmdo` to carry the new module

name, we need to bump the haddock submodule to account or the new shape of

these constructors.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-27T11:55:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revamp the treatment of auxiliary bindings for derived instances

This started as a simple fix for #18321 that organically grew into a

much more sweeping refactor of how auxiliary bindings for derived

instances are handled. I have rewritten `Note [Auxiliary binders]`

in `GHC.Tc.Deriv.Generate` to explain all of the moving parts, but

the highlights are:

* Previously, the OccName of each auxiliary binding would be given

  a suffix containing a hash of its package name, module name, and

  parent data type to avoid name clashes. This was needlessly

  complicated, so we take the more direct approach of generating

  `Exact` `RdrName`s for each auxiliary binding with the same

  `OccName`, but using an underlying `System` `Name` with a fresh

  `Unique` for each binding. Unlike hashes, allocating new `Unique`s

  does not require any cleverness and avoid name clashes all the

  same...

* ...speaking of which, in order to convince the renamer that multiple

  auxiliary bindings with the same `OccName` (but different

  `Unique`s) are kosher, we now use `rnLocalValBindsLHS` instead of

  `rnTopBindsLHS` to rename auxiliary bindings. Again, see

  `Note [Auxiliary binders]` for the full story.

* I have removed the `DerivHsBind` constructor for

  `DerivStuff`—which was only used for `Data.Data`-related

  auxiliary bindings—and refactored `gen_Data_binds` to use

  `DerivAuxBind` instead. This brings the treatment of

  `Data.Data`-related auxiliary bindings in line with every other

  form of auxiliary binding.

Fixes #18321.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bignum: fix division by zero (#18359)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix ghc-bignum exceptions

We must ensure that exceptions are not simplified. Previously we used:

   case raiseDivZero of

      _ -> 0## -- dummyValue

But it was wrong because the evaluation of `raiseDivZero` was removed and

the dummy value was directly returned. See new Note [ghc-bignum exceptions].

I've also removed the exception triggering primops which were fragile.

We don't need them to be primops, we can have them exported by ghc-prim.

I've also added a test for #18359 which triggered this patch.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-27T11:56:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Better loop detection in findTypeShape

Andreas pointed out, in !3466, that my fix for #18304 was not

quite right.  This patch fixes it properly, by having just one

RecTcChecker rather than (implicitly) two nested ones, in

findTypeShape.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-27T11:57:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: don't store buildTag

`DynFlags.buildTag` was a field created from the set of Ways in

`DynFlags.ways`. It had to be kept in sync with `DynFlags.ways` which

was fragile. We want to avoid global state like this (#17957).

Moreover in #14335 we also want to support loading units with different

ways: target units would still use `DynFlags.ways` but plugins would use

`GHC.Driver.Ways.hostFullWays`. To avoid having to deal both with build

tag and with ways, we recompute the buildTag on-the-fly (should be

pretty cheap) and we remove `DynFlags.buildTag` field.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-06-27T11:57:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't generalize when typechecking a tuple section

The code is simpler and cleaner.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-06-28T09:19:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">RTS: Refactor Haskell-C glue for PPC 64-bit

Make sure the stack is 16 byte aligned even when reserved stack

bytes are not a multiple of 16 bytes.

Avoid saving r2 (TOC). On ELF v1 the function descriptor of StgReturn

has the same TOC as StgRun, on ELF v2 the TOC is recomputed in the

function prologue.

Use the ABI provided functions to save clobbered GPRs and FPRs.

Improve comments. Describe what the stack looks like and how it relates

to the respective ABIs.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/42f797b0ad034a92389e7081aa50ef4ab3434d01">42f797b0</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-28T09:19:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use NHsCoreTy to embed types into GND-generated code

`GeneralizedNewtypeDeriving` is in the unique situation where it must

produce an `LHsType GhcPs` from a Core `Type`. Historically, this was

done with the `typeToLHsType` function, which walked over the entire

`Type` and attempted to construct an `LHsType` with the same overall

structure. `typeToLHsType` is quite complicated, however, and has

been the subject of numerous bugs over the years (e.g., #14579).

Luckily, there is an easier way to accomplish the same thing: the

`XHsType` constructor of `HsType`. `XHsType` bundles an `NHsCoreTy`,

which allows embedding a Core `Type` directly into an `HsType`,

avoiding the need to laboriously convert from one to another (as

`typeToLHsType` did). Moreover, renaming and typechecking an

`XHsType` is simple, since one doesn't need to do anything to a

Core `Type`...

...well, almost. For the reasons described in

`Note [Typechecking NHsCoreTys]` in `GHC.Tc.Gen.HsType`, we must

apply a substitution that we build from the local `tcl_env` type

environment. But that's a relatively modest price to pay.

Now that `GeneralizedNewtypeDeriving` uses `NHsCoreTy`, the

`typeToLHsType` function no longer has any uses in GHC, so this patch

rips it out. Some additional tweaks to `hsTypeNeedsParens` were

necessary to make the new `-ddump-deriv` output correctly

parenthesized, but other than that, this patch is quite

straightforward.

This is a mostly internal refactoring, although it is likely that

`GeneralizedNewtypeDeriving`-generated code will now need fewer

language extensions in certain situations than it did before.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/68530b1cd45629e5a353a37df80195ac54d26ade">68530b1c</a></strong>

<div>

<span>by Jan Hrček</span>

<i>at 2020-06-28T09:20:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix duplicated words and typos in comments and user guide

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15b79befc246aa9c63dd084012dc7843ea93daaa">15b79bef</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-28T09:20:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add integer-gmp's ghc.mk and GNUmakefile to .gitignore

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-06-28T09:21:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a typo in Lint

This simple error in GHC.Core.Litn.lintJoinLams meant that

Lint reported bogus errors.

Fixes #18399

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-06-30T07:10:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reject nested foralls/contexts in instance types more consistently

GHC is very wishy-washy about rejecting instance declarations with

nested `forall`s or contexts that are surrounded by outermost

parentheses. This can even lead to some strange interactions with

`ScopedTypeVariables`, as demonstrated in #18240. This patch makes

GHC more consistently reject instance types with nested

`forall`s/contexts so as to prevent these strange interactions.

On the implementation side, this patch tweaks `splitLHsInstDeclTy`

and `getLHsInstDeclHead` to not look through parentheses, which can

be semantically significant. I've added a

`Note [No nested foralls or contexts in instance types]` in

`GHC.Hs.Type` to explain why. This also introduces a

`no_nested_foralls_contexts_err` function in `GHC.Rename.HsType` to

catch nested `forall`s/contexts in instance types. This function is

now used in `rnClsInstDecl` (for ordinary instance declarations) and

`rnSrcDerivDecl` (for standalone `deriving` declarations), the latter

of which fixes #18271.

On the documentation side, this adds a new

"Formal syntax for instance declaration types" section to the GHC

User's Guide that presents a BNF-style grammar for what is and isn't

allowed in instance types.

Fixes #18240. Fixes #18271.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-06-30T07:10:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add ghc-bignum to 8.12 release notes

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/81704a6f3b155b0bfbc20f53cd821be3cb9006a7">81704a6f</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-06-30T07:10:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update ssh keys in CI performance metrics upload script

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85310fb83fdb7d7294bd453026102fc42000bf14">85310fb8</a></strong>

<div>

<span>by Joshua Price</span>

<i>at 2020-06-30T07:10:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing Ix instances for tuples of size 6 through 15 (#16643)

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-07-01T15:41:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -XLexicalNegation (GHC Proposal #229)

This patch introduces a new extension, -XLexicalNegation, which detects

whether the minus sign stands for negation or subtraction using the

whitespace-based rules described in GHC Proposal #229.

Updates haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Martin Handley</span>

<i>at 2020-07-01T15:42:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">#17169: Clarify Fixed's Enum instance.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-01T15:42:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve debug tracing for substitution

This patch improves debug tracing a bit (#18395)

* Remove the ancient SDoc argument to substitution, replacing it

  with a HasDebugCallStack constraint. The latter does the same

  job (indicate the call site) but much better.

* Add HasDebugCallStack to simpleOptExpr, exprIsConApp_maybe

  I needed this to help nail the lookupIdSubst panic in

  #18326, #17784

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-01T15:43:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add most common return values for `os` and `arch`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/76d8cc744977d98f6a427b1816198709e2d2e856">76d8cc74</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-01T15:44:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Desugar quoted uses of DerivingVia and expression type signatures properly

The way that `GHC.HsToCore.Quote` desugared quoted `via` types (e.g.,

`deriving via forall a. [a] instance Eq a => Eq (List a)`) and

explicit type annotations in signatures (e.g.,

`f = id @a :: forall a. a -> a`) was completely wrong, as it did not

implement the scoping guidelines laid out in

`Note [Scoped type variables in bindings]`. This is easily fixed.

While I was in town, I did some minor cleanup of related Notes:

* `Note [Scoped type variables in bindings]` and

  `Note [Scoped type variables in class and instance declarations]`

  say very nearly the same thing. I decided to just consolidate the

  two Notes into `Note [Scoped type variables in quotes]`.

* `Note [Don't quantify implicit type variables in quotes]` is

  somewhat outdated, as it predates GHC 8.10, where the

  `forall`-or-nothing rule requires kind variables to be explicitly

  quantified in the presence of an explicit `forall`. As a result,

  the running example in that Note doesn't even compile. I have

  changed the example to something simpler that illustrates the

  same point that the original Note was making.

Fixes #18388.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/44d6a3352d708785b75aeb616bfc7efff839184e">44d6a335</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-02T02:54:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">T16012: Be verbose on failure.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-02T02:55:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump ghc-prim version to 0.7.0

Fixes #18279. Bumps the `text` submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/23e4e04700f840e3c4e75ccb2085aea05bfb5318">23e4e047</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T10:46:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix PowerPC64le support (#17601)

[ci skip]

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T10:47:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCG: correctly handle addresses with huge offsets (#15570)

Before this patch we could generate addresses of this form:

   movzbl cP0_str+-9223372036854775808,%eax

The linker can't handle them because the offset is too large:

   ld.lld: error: Main.o:(.text+0xB3): relocation R_X86_64_32S out of range: -9223372036852653050 is not in [-2147483648, 2147483647]

With this patch we detect those cases and generate:

   movq $-9223372036854775808,%rax

   addq $cP0_str,%rax

   movzbl (%rax),%eax

I've also refactored `getAmode` a little bit to make it easier to

understand and to trace.

</pre>

</li>

<li>

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

<div>

<span>by Gabor Greif</span>

<i>at 2020-07-02T20:07:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">No need for CURSES_INCLUDE_DIRS

This is a leftover from ef63ff27251a20ff11e58c9303677fa31e609a88</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-02T20:08:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace Opt_SccProfilingOn flag with sccProfilingEnabled helper function

SCC profiling was enabled in a convoluted way: if WayProf was enabled,

Opt_SccProfilingOn general flag was set (in

`GHC.Driver.Ways.wayGeneralFlags`), and then this flag was queried in

various places.

There is no need to go via general flags, so this patch defines a

`sccProfilingEnabled :: DynFlags -> Bool` helper function that just

checks whether WayProf is enabled.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-03T02:49:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ProfHeap: Only allocate the Censuses that we need

When not LDV profiling there is no reason to allocate 32 Censuses; one

will do. This is a very small memory footprint optimisation, but it

comes for free.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-03T02:49:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/ProfHeap: Free old allocations when reinitialising Censuses

Previously when not LDV profiling we would repeatedly reinitialise

`censuses[0]` with `initEra`. This failed to free the `Arena` and

`HashTable` from the old census, resulting in a memory leak.

Fixes #18348.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/34be6523a220b2be972b391d8ad26b75f7c26eb1">34be6523</a></strong>

<div>

<span>by Valery Tolstov</span>

<i>at 2020-07-03T02:50:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Mention flags that are not enabled by -Wall (#18372)

* Mention missing flags that are not actually enabled by -Wall (docs/users_guide/using-warnings.rst)

* Additionally remove -Wmissing-monadfail-instances from the list of flags enabled by -Wcompat, as it is not the case since 8.8

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-03T02:50:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: support R9 and R10 registers

d535ef006d85dbdb7cda2b09c5bc35cb80108909 allowed the use of up to 10

vanilla registers but didn't update LLVM backend to support them. This

patch fixes it.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-03T08:37:42+01:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve handling of data type return kinds

Following a long conversation with Richard, this patch tidies up the

handling of return kinds for data/newtype declarations (vanilla,

family, and instance).

I have substantially edited the Notes in TyCl, so they would

bear careful reading.

Fixes #18300, #18357

In GHC.Tc.Instance.Family.newFamInst we were checking some Lint-like

properties with ASSSERT.  Instead Richard and I have added

a proper linter for axioms, and called it from lintGblEnv, which in

turn is called in tcRnModuleTcRnM

New tests (T18300, T18357) cause an ASSERT failure in HEAD.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/41d2649288a5debcb4c8003e54b7d3072ab951c5">41d26492</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-03T17:33:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: avoid the use of sdocWithDynFlags in GHC.Core.Rules (#17957)

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-03T17:34:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add the __GHC_FULL_VERSION__ CPP macro to expose the full GHC version

</pre>

</li>

<li>

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

<div>

<span>by Chaitanya Koparkar</span>

<i>at 2020-07-07T13:55:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-prim: Turn some comments into haddocks

[ci skip]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/37743f91a3f5018a8894ca6d35e8b423e4e08b50">37743f91</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Support `timesInt2#` in LLVM backend

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/46397e530e1b107c6b8932f7ca79ebab53a3249a">46397e53</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">`genericIntMul2Op`: Call `genericWordMul2Op` directly

This unblocks a refactor, and removes partiality. It might be a PowerPC

regression but that should be fixable.

</pre>

</li>

<li>

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

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify `PrimopCmmEmit`

Follow @simonpj's suggestion of pushing the "into regs" logic into

`emitPrimOp`. With the previous commit getting rid of the recursion in

`genericIntMul2Op`, this is now an easy refactor.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6607f203fb9ad11af1463145810e1bd3c6c4f2c8">6607f203</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">`opAllDone` -> `opIntoRegs`

The old name was and terrible and became worse after the previous

commit's refactor moved non-trivial funcationlity into its body.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:00-04:00</i>

</div>

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

We shouldn't directly call 'genericWordMul2Op' in genericIntMul2Op

because a target may provide a faster primop for 'WordMul2Op': we'd

better use it!

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/686e72253aed3880268dd6858eadd8c320f09e97">686e7225</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[linker/rtsSymbols] More linker symbols

Mostly symbols needed for aarch64/armv7l

and in combination with musl, where we have

to rely on loading *all* objects/archives

- __stack_chk_* only when not DYNAMIC

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">better if guards.

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix (1)

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-07T13:56:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">AArch32 symbols only on aarch32.

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add -flink-rts flag to link the rts when linking a shared or static library #18072

By default we don't link the RTS when linking shared libraries because in the

most usual mode a shared library is an intermediary product, for example a

Haskell library, that will be linked into some executable in the end. So we

wish to defer the RTS flavour to link to the final link.

However sometimes the final product is the shared library, for example when

writing a plugin for some other system, so we do wish the shared library to

link the RTS.

For consistency we also make -staticlib honor this flag and its inversion.

-staticlib currently implies -flink-shared.

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-07T13:56:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: link check-ppr against debugging RTS if ghcDebugged

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts linker: teach the linker about GLIBC's special handling of *stat, mknod and atexit functions #7072

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9615343363a68313c4bfdb068696002ecca7786e">96153433</a></strong>

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: make hadrian/ghci use the bootstrap compiler from configure #18190

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-07T13:56:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: ignore cabal configure verbosity related flags #18131

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7332bbffee9e2a712508540200eb52ed3d227426">7332bbff</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-07T13:56:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Widen T12234 acceptance window to 2%

Previously it wasn't uncommon to see +/-1% fluctuations in compiler

allocations on this test.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/180b63136f25d9fedb764cb9bc23637e7781ed4e">180b6313</a></strong>

<div>

<span>by Gabor Greif</span>

<i>at 2020-07-07T13:56:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">When running libtool, report it as such</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">BigNum: rename BigNat types

Before this patch BigNat names were confusing because we had:

* GHC.Num.BigNat.BigNat: unlifted type used everywhere else

* GHC.Num.BigNat.BigNatW: lifted type only used to share static constants

* GHC.Natural.BigNat: lifted type only used for backward compatibility

After this patch we have:

* GHC.Num.BigNat.BigNat#: unlifted type

* GHC.Num.BigNat.BigNat: lifted type (reexported from GHC.Natural)

Thanks to @RyanGlScott for spotting this.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/929d26db3080ec49ab67690952a316fc082b479f">929d26db</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: don't build ghc-bignum with stage0

Noticed by @Ericson2314

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: ghc-gmp.h shouldn't be a compiler dependency

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-07T13:56:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: factor out pprUnitId from "Outputable UnitId" instance

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/204f3f5ddec56403bfb12e74291b3b1d14824138">204f3f5d</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-07T13:56:18-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unused function pprHsForAllExtra (#18423)

The function `pprHsForAllExtra` was called only on `Nothing`

since 2015 (1e041b7382b6aa).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3033e0e4940e6ecc43f478f1dcfbd0c3cb1e3ef8">3033e0e4</a></strong>

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-07-08T20:36:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: add flag to skip rebuilding dependency information #17636

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-09T09:49:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix GHCi :print on big-endian platforms

On big-endian platforms executing

  import GHC.Exts

  data Foo = Foo Float# deriving Show

  foo = Foo 42.0#

  foo

  :print foo

results in an arithmetic overflow exception which is caused by function

index where moveBytes equals

  word_size - (r + item_size_b) * 8

Here we have a mixture of units. Both, word_size and item_size_b have

unit bytes whereas r has unit bits.  On 64-bit platforms moveBytes

equals then

  8 - (0 + 4) * 8

which results in a negative and therefore invalid second parameter for a

shiftL operation.

In order to make things more clear the expression

  (word .&. (mask `shiftL` moveBytes)) `shiftR` moveBytes

is equivalent to

  (word `shiftR` moveBytes) .&. mask

On big-endian platforms the shift must be a left shift instead of a

right shift. For symmetry reasons not a mask is used but two shifts in

order to zero out bits. Thus the fixed version equals

  case endian of

    BigEndian    -> (word `shiftL` moveBits) `shiftR` zeroOutBits `shiftL` zeroOutBits

    LittleEndian -> (word `shiftR` moveBits) `shiftL` zeroOutBits `shiftR` zeroOutBits

Fixes #16548 and #14455

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3656dff8259199d0dab2d1a1f1b887c252a9c1a3">3656dff8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-09T09:50:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">LLVM: fix MO_S_Mul2 support (#18434)

The value indicating if the carry is useful wasn't taken into account.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-10T10:33:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define multiShotIO and use it in mkSplitUniqueSupply

This patch is part of the ongoing eta-expansion saga;

see #18238.

It implements a neat trick (suggested by Sebastian Graf)

that allows the programmer to disable the default one-shot behaviour

of IO (the "state hack").  The trick is to use a new multiShotIO

function; see Note [multiShotIO].  For now, multiShotIO is defined

here in Unique.Supply; but it should ultimately be moved to the IO

library.

The change is necessary to get good code for GHC's unique supply;

see Note [Optimising the unique supply].

However it makes no difference to GHC as-is.  Rather, it makes

a difference when a subsequent commit

   Improve eta-expansion using ArityType

lands.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-10T10:33:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make arityType deal with join points

As Note [Eta-expansion and join points] describes,

this patch makes arityType deal correctly with join points.

What was there before was not wrong, but yielded lower

arities than it could.

Fixes #18328

In base GHC this makes no difference to nofib.

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

         n-body          -0.1%     -0.1%     -1.2%     -1.1%      0.0%

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

            Min          -0.1%     -0.1%    -55.0%    -56.5%      0.0%

            Max          -0.0%      0.0%    +16.1%    +13.4%      0.0%

 Geometric Mean          -0.0%     -0.0%    -30.1%    -31.0%     -0.0%

But it starts to make real difference when we land the change to the

way mkDupableAlts handles StrictArg, in fixing #13253 and friends.

I think this is because we then get more non-inlined join points.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-11T12:17:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve eta-expansion using ArityType

As #18355 shows, we were failing to preserve one-shot info when

eta-expanding.  It's rather easy to fix, by using ArityType more,

rather than just Arity.

This patch is important to suport the one-shot monad trick;

see #18202.  But the extra tracking of one-shot-ness requires

the patch

   Define multiShotIO and use it in mkSplitUniqueSupply

If that patch is missing, ths patch makes things worse in

GHC.Types.Uniq.Supply.  With it, however, we see these improvements

    T3064     compiler bytes allocated -2.2%

    T3294     compiler bytes allocated -1.3%

    T12707    compiler bytes allocated -1.3%

    T13056    compiler bytes allocated -2.2%

Metric Decrease:

    T3064

    T3294

    T12707

    T13056

</pre>

</li>

<li>

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

<div>

<span>by Artem Pelenitsyn</span>

<i>at 2020-07-12T02:53:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">add reproducer for #15630

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-12T02:53:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Give Uniq[D]FM a phantom type for its key.

This fixes #17667 and should help to avoid such issues going forward.

The changes are mostly mechanical in nature. With two notable

exceptions.

* The register allocator.

  The register allocator references registers by distinct uniques.

  However they come from the types of VirtualReg, Reg or Unique in

  various places. As a result we sometimes cast the key type of the

  map and use functions which operate on the now typed map but take

  a raw Unique as actual key. The logic itself has not changed it

  just becomes obvious where we do so now.

* <Type>Env Modules.

As an example a ClassEnv is currently queried using the types `Class`,

`Name`, and `TyCon`. This is safe since for a distinct class value all

these expressions give the same unique.

    getUnique cls

    getUnique (classTyCon cls)

    getUnique (className cls)

    getUnique (tcName $ classTyCon cls)

This is for the most part contained within the modules defining the

interface. However it requires us to play dirty when we are given a

`Name` to lookup in a `UniqFM Class a` map. But again the logic did

not change and it's for the most part hidden behind the Env Module.

Some of these cases could be avoided by refactoring but this is left

for future work.

We also bump the haddock submodule as it uses UniqFM.

</pre>

</li>

<li>

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

<div>

<span>by Aaron Allen</span>

<i>at 2020-07-13T09:00:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Warn about empty Char enumerations (#18402)

Currently the "Enumeration is empty" warning (-Wempty-enumerations)

only fires for numeric literals. This patch adds support for `Char`

literals so that enumerating an empty list of `Char`s will also

trigger the warning.

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-13T09:01:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: build check-ppr dynamic if GHC is build dynamic

Fixes #18361

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use dumpStyle when printing inlinings

This just makes debug-printing consistent,

and more informative.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reduce result discount in conSize

Ticket #18282 showed that the result discount given by conSize

was massively too large.  This patch reduces that discount to

a constant 10, which just balances the cost of the constructor

application itself.

Note [Constructor size and result discount] elaborates, as

does the ticket #18282.

Reducing result discount reduces inlining, which affects perf.  I

found that I could increase the unfoldingUseThrehold from 80 to 90 in

compensation; in combination with the result discount change I get

these overall nofib numbers:

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

          boyer          -0.2%     +5.4%     -3.2%     -3.4%      0.0%

       cichelli          -0.1%     +5.9%    -11.2%    -11.7%      0.0%

      compress2          -0.2%     +9.6%     -6.0%     -6.8%      0.0%

   cryptarithm2          -0.1%     -3.9%     -6.0%     -5.7%      0.0%

         gamteb          -0.2%     +2.6%    -13.8%    -14.4%      0.0%

         genfft          -0.1%     -1.6%    -29.5%    -29.9%      0.0%

             gg          -0.0%     -2.2%    -17.2%    -17.8%    -20.0%

           life          -0.1%     -2.2%    -62.3%    -63.4%      0.0%

           mate          +0.0%     +1.4%     -5.1%     -5.1%    -14.3%

         parser          -0.2%     -2.1%     +7.4%     +6.7%      0.0%

      primetest          -0.2%    -12.8%    -14.3%    -14.2%      0.0%

         puzzle          -0.2%     +2.1%    -10.0%    -10.4%      0.0%

            rsa          -0.2%    -11.7%     -3.7%     -3.8%      0.0%

         simple          -0.2%     +2.8%    -36.7%    -38.3%     -2.2%

   wheel-sieve2          -0.1%    -19.2%    -48.8%    -49.2%    -42.9%

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

            Min          -0.4%    -19.2%    -62.3%    -63.4%    -42.9%

            Max          +0.3%     +9.6%     +7.4%    +11.0%    +16.7%

 Geometric Mean          -0.1%     -0.3%    -17.6%    -18.0%     -0.7%

I'm ok with these numbers, remembering that this change removes

an *exponential* increase in code size in some in-the-wild cases.

I investigated compress2.  The difference is entirely caused by this

function no longer inlining

WriteRoutines.$woutputCodes

  = \ (w :: [CodeEvent]) ->

      let result_s1Sr

            = case WriteRoutines.outputCodes_$s$woutput w 0# 0# 8# 9# of

                (# ww1, ww2 #) -> (ww1, ww2)

      in (# case result_s1Sr of (x, _) ->

              map @Int @Char WriteRoutines.outputCodes1 x

         , case result_s1Sr of { (_, y) -> y } #)

It was right on the cusp before, driven by the excessive result

discount.  Too bad!

Happily, the compiler/perf tests show a number of improvements:

    T12227     compiler bytes-alloc  -6.6%

    T12545     compiler bytes-alloc  -4.7%

    T13056     compiler bytes-alloc  -3.3%

    T15263     runtime  bytes-alloc -13.1%

    T17499     runtime  bytes-alloc -14.3%

    T3294      compiler bytes-alloc  -1.1%

    T5030      compiler bytes-alloc -11.7%

    T9872a     compiler bytes-alloc  -2.0%

    T9872b     compiler bytes-alloc  -1.2%

    T9872c     compiler bytes-alloc  -1.5%

Metric Decrease:

    T12227

    T12545

    T13056

    T15263

    T17499

    T3294

    T5030

    T9872a

    T9872b

    T9872c

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-13T14:52:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Widen acceptance threshold on T5837

This test is positively tiny and consequently the bytes allocated

measurement will be relatively noisy. Consequently I have seen this

fail spuriously quite often.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/118e1c3da622f17c67b4e0fbc12ed7c7084055dc">118e1c3d</a></strong>

<div>

<span>by Alp Mestanogullari</span>

<i>at 2020-07-14T21:30:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler: re-engineer the treatment of rebindable if

Executing on the plan described in #17582, this patch changes the way if expressions

are handled in the compiler in the presence of rebindable syntax. We get rid of the

SyntaxExpr field of HsIf and instead, when rebindable syntax is on, we rewrite the HsIf

node to the appropriate sequence of applications of the local `ifThenElse` function.

In order to be able to report good error messages, with expressions as they were

written by the user (and not as desugared by the renamer), we make use of TTG

extensions to extend GhcRn expression ASTs with an `HsExpansion` construct, which

keeps track of a source (GhcPs) expression and the desugared (GhcRn) expression that

it gives rise to. This way, we can typecheck the latter while reporting the former in

error messages.

In order to discard the error context lines that arise from typechecking the desugared

expressions (because they talk about expressions that the user has not written), we

carefully give a special treatment to the nodes fabricated by this new renaming-time

transformation when typechecking them. See Note [Rebindable syntax and HsExpansion]

for more details. The note also includes a recipe to apply the same treatment to

other rebindable constructs.

Tests 'rebindable11' and 'rebindable12' have been added to make sure we report

identical error messages as before this patch under various circumstances.

We also now disable rebindable syntax when processing untyped TH quotes, as per

the discussion in #18102 and document the interaction of rebindable syntax and

Template Haskell, both in Note [Template Haskell quotes and Rebindable Syntax]

and in the user guide, adding a test to make sure that we do not regress in

that regard.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/64c774b043a2d9be3b98e445990c795f070dab3f">64c774b0</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-14T21:31:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Explain why keeping DynFlags in AnalEnv saves allocation.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/254245d01e3c1d4f9072abc4372fd3fb0a6ece9f">254245d0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-14T21:32:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs/users-guide: Update default -funfolding-use-threshold value

This was changed in 3d2991f8 but I neglected to update the

documentation. Fixes #18419.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-14T21:32:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Escape backslashes in json profiling reports properly.

I also took the liberty to do away the fixed buffer size for escaping.

Using a fixed size here can only lead to issues down the line.

Fixes #18438.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2379722438cb551210c4899119ade05989c17166">23797224</a></strong>

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-07-14T21:33:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">.gitlab: re-enable integer-simple substitute (BIGNUM_BACKEND)

Recently build system migrated from INTEGER_LIBRARY to BIGNUM_BACKEND.

But gitlab CI was never updated. Let's enable BIGNUM_BACKEND=native.

Bug: https://gitlab.haskell.org/ghc/ghc/-/issues/18437

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

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

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-07-14T21:33:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-bignum: bring in sync .hs-boot files with module declarations

Before this change `BIGNUM_BACKEND=native` build was failing as:

```

libraries/ghc-bignum/src/GHC/Num/BigNat/Native.hs:708:16: error:

    * Variable not in scope: naturalFromBigNat# :: WordArray# -> t

    * Perhaps you meant one of these:

        `naturalFromBigNat' (imported from GHC.Num.Natural),

        `naturalToBigNat' (imported from GHC.Num.Natural)

    |

708 |           m' = naturalFromBigNat# m

    |

```

This happens because `.hs-boot` files are slightly out of date.

This change brings in data and function types in sync.

Bug: https://gitlab.haskell.org/ghc/ghc/-/issues/18437

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-14T21:33:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/Disassembler.c: Use FMT_HexWord for printing values in hex format

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58ae62ebb5750e4dfbdb171efde8e3064b7afea8">58ae62eb</a></strong>

<div>

<span>by Matthias Andreas Benkard</span>

<i>at 2020-07-14T21:34:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">macOS: Load frameworks without stating them first.

macOS Big Sur makes the following change to how frameworks are shipped

with the OS:

> New in macOS Big Sur 11 beta, the system ships with a built-in

> dynamic linker cache of all system-provided libraries. As part of

> this change, copies of dynamic libraries are no longer present on

> the filesystem. Code that attempts to check for dynamic library

> presence by looking for a file at a path or enumerating a directory

> will fail. Instead, check for library presence by attempting to

> dlopen() the path, which will correctly check for the library in the

> cache. (62986286)

https://developer.apple.com/documentation/macos-release-notes/macos-big-sur-11-beta-release-notes/

Therefore, the previous method of checking whether a library exists

before attempting to load it makes GHC.Runtime.Linker.loadFramework

fail to find frameworks installed at /System/Library/Frameworks.

GHC.Runtime.Linker.loadFramework now opportunistically loads the

framework libraries without checking for their existence first,

failing only if all attempts to load a given framework from any of the

various possible locations fail.

</pre>

</li>

<li>

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

<div>

<span>by Matthias Andreas Benkard</span>

<i>at 2020-07-14T21:34:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">loadFramework: Output the errors collected in all loading attempts.

With the recent change away from first finding and then loading a

framework, loadFramework had no way of communicating the real reason

why loadDLL failed if it was any reason other than the framework

missing from the file system.  It now collects all loading attempt

errors into a list and concatenates them into a string to return to

the caller.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/51dbfa52df483822b99bb191d2ffc0943954e1d3">51dbfa52</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T04:05:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">StgToCmm: Use CmmRegOff smart constructor

Previously we would generate expressions of the form

`CmmRegOff BaseReg 0`. This should do no harm (and really should be

handled by the NCG anyways) but it's better to just generate a plain

`CmmReg`.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T04:06:08-04:00</i>

</div>

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

Test due to @monoidal.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Cabal submodule

Updates a variety of tests as Cabal is now more strict about Cabal file

form.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Drop Windows Vista support, require Windows 7

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/00a23bfda4840546075ec2b2e18f61380b360dfc">00a23bfd</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update Windows FileSystem wrapper utilities.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/459e1c5f7c71e37ed8bb239c57bdec441d278fff">459e1c5f</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Use SlimReaderLocks and ConditonalVariables provided by the OS instead of emulated ones

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/763088fc3c14c8687685fe811eac13d216971840">763088fc</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Small linker comment and ifdef cleanups

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Flush event logs eagerly.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Refactor Buffer structures to be able to track async operations

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/356dc3feae967b1c361130f1f356ef9ad6a693e4">356dc3fe</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Implement new Console API

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add IOPort synchronization primitive

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/71245fcce24723910f12f934fbc4c700658b727a">71245fcc</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add new io-manager cmdline options

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Init Windows console Codepage to UTF-8.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58ef63668ec395aa7a2b250d9930641305d646e2">58ef6366</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add unsafeSplat to GHC.Event.Array

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add size and iterate to GHC.Event.IntTable.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/050da6dd42d0cb293c7fce4a5ccdeb5abe1aadb4">050da6dd</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Switch Testsuite to test winio by default

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Multiple refactorings and support changes.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4489af6bad11a198e9e6c192f41e17020f28d0c1">4489af6b</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: core threaded I/O manager

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/64d8f2fe2d27743e2986d2176b1aa934e5484d7a">64d8f2fe</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: core non-threaded I/O manager

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix a scheduler bug with the threaded-runtime.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/84ea3d1492127442e2d416f1f576a5921186ada4">84ea3d14</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Relaxing some constraints in io-manager.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix issues with non-threaded I/O manager after split.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove some barf statements that are a bit strict.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01423fd205809e884fd9b7b69286108ca06a0d98">01423fd2</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Expand comments describing non-threaded loop

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix FileSize unstat-able handles

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Implement new tempfile routines for winio

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix input truncation when reading from handle.

This was caused by not upholding the read buffer invariant

that bufR == bufL == 0 for empty read buffers.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix output truncation for writes larger than buffer size

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Rewrite bufWrite.

I think it's far easier to follow the code now.

It's also correct now as I had still missed a spot

where we didn't update the offset.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix offset set by bufReadEmpty.

bufReadEmpty returns the bytes read *including* content that

was already buffered,

But for calculating the offset we only care about the number

of bytes read into the new buffer.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/750ebaeec06d7ee118abfbb29142c12fb31730cc">750ebaee</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Clean up code surrounding IOPort primitives.

According to phyx these should only be read and written once per

object. Not neccesarily in that order.

To strengthen that guarantee the primitives will now throw an

exception if we violate this invariant.

As a consequence we can eliminate some code from their primops.

In particular code dealing with multiple queued readers/writers

now simply checks the invariant and throws an exception if it

was violated. That is in contrast to mvars which will do things

like wake up all readers, queue multi writers etc.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix multi threaded threadDelay and a few other small changes.

Multithreaded threadDelay suffered from a race condition

based on the ioManagerStatus. Since the status isn't needed

for WIO I removed it completely.

This resulted in a light refactoring, as consequence we will always

wake up the IO manager using interruptSystemManager, which uses

`postQueuedCompletionStatus` internally.

I also added a few comments which hopefully makes the code easier to

dive into for the next person diving in.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">wionio: Make IO subsystem check a no-op on non-windows platforms.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/29bcd9363f2712524f7720377f19cb885adf2825">29bcd936</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Set handle offset when opening files in Append mode.

Otherwise we would truncate the file.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove debug event log trace

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix sqrt and openFile009 test cases

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57017cb7454cbfaa1b011693e7fb141fbf519ccf">57017cb7</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Allow hp2ps to build with -DDEBUG

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update output of T9681 since we now actually run it.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: A few more improvements to the IOPort primitives.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/39afc4a785a37f238a9004b2f6882d1951953c07">39afc4a7</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix expected tempfiles output.

Tempfiles now works properly on windows, as such we can

delete the win32 specific output.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Assign thread labels to IOManager threads.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Properly check for the tso of an incall to be zero.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Mark FD instances as unsupported under WINIO.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix threadDelay maxBound invocations.

Instead of letting the ns timer overflow now clamp it at

(maxBound :: Word64) ns. That still gives a few hundred

years.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add comments/cleanup an import in base

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Mark outstanding_service_requests volatile.

As far as I know C(99) gives no guarantees for code like

    bool condition;

    ...

    while(condition)

        sleep();

that condition will be updated if it's changed by another thread.

So we are explicit here and mark it as volatile, this will force

a reload from memory on each iteration.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Make last_event a local variable

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add comment about thread safety of processCompletion.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: nonthreaded: Create io processing threads in main thread.

We now set a flag in the IO thread. The scheduler when looking for work

will check the flag and create/queue threads accordingly.

We used to create these in the IO thread. This improved performance

but caused frequent segfaults. Thread creation/allocation is only safe to

do if nothing currently accesses the storeagemanager. However without

locks in the non-threaded runtime this can't be guaranteed.

This shouldn't change performance all too much.

In the past we had:

* IO: Create/Queue thread.

* Scheduler: Runs a few times. Eventually picks up IO processing thread.

Now it's:

* IO: Set flag to queue thread.

* Scheduler: Pick up flag, if set create/queue thread. Eventually picks up IO processing thread.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add an exported isHeapAlloced function to the RTS

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Queue IO processing threads at the front of the queue.

This will unblock the IO thread sooner hopefully leading to higher

throughput in some situations.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: ThreadDelay001: Use higher resolution timer.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/451b5f96c8a3366584a62034747c8b78fc3b0486">451b5f96</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update T9681 output, disable T4808 on windows.

T4808 tests functionality of the FD interface which won't be supported

under WINIO.

T9681 just has it's expected output tweaked.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Wake io manager once per registerTimeout.

Which is implicitly done in editTimeouts, so need to wake it

up twice.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update placeholder comment with actual function name.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Always lock win32 event queue

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Display thread labels when tracing scheduler events.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/06542b033116bfc4b47c80bdeab44ed1d99005bb">06542b03</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Refactor non-threaded runner thread and scheduler interface.

Only use a single communication point (registerAlertableWait) to inform

the C side aobut both timeouts to use as well as outstanding requests.

Also queue a haskell processing thread after each return from alertable

waits. This way there is no risk of us missing a timer event.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/256299b13e17044d6904a85043130d13bc592a62">256299b1</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove outstanding_requests from runner.

We used a variable to keep track of situations where we got

entries from the IO port, but all of them had already been

canceled. While we can avoid some work that way this case

seems quite rare.

So we give up on tracking this and instead always assume at

least one of the returned entries is valid.

If that's not the case no harm is done, we just perform some

additional work. But it makes the runner easier to reason about.

In particular we don't need to care if another thread modifies

oustanding_requests after we return from waiting on the IO Port.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Various fixes related to rebase and testdriver

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix rebase artifacts

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Rename unsafeSplat to unsafeCopyFromBuffer

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove unused size/iterate operations from IntTable

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/16bab48ef69866725d2ab20ca7bd1da5f5a70000">16bab48e</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Detect running IO Backend via peeking at RtsConfig

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: update temp path so GCC etc can handle it.

Also fix PIPE support, clean up error casting, fix memory leaks

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2092bc542516461eeb06d855dfbe9b04438767bc">2092bc54</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Minor comments/renamings

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Checking if an error code indicates completion is now a function.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/362176fd9189e73083fd2a2012c9b5be1e3fd05b">362176fd</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Small refactor in withOverlappedEx

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32e20597b2fe5864b578c732501fe20d899e8f9c">32e20597</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: A few comments and commented out dbxIO

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Don't drop buffer offset in byteView/cwcharView

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: revert BHandle changes.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix imports

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: update ghc-cabal to handle new Cabal submodule bump

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Only compile sources on Windows

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Actually return Nothing on EOF for non-blocking read

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/895a3beb26de69f5611ea496dddb2b121c1dd5c1">895a3beb</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Deduplicate logic in encodeMultiByte[Raw]IO.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Deduplicate openFile logic

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix -werror issue in encoding file

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Don't mention windows specific functions when building on Linux.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: add a note about file locking in the RTS.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add version to @since annotation

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Rename GHC.Conc.IOCP -> GHC.Conc.WinIO

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1854fc23489baa39cb37f8d49ff74b7ee78d7de1">1854fc23</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Expand GHC.Conc.POSIX description

It now explains users may not use these functions when

using the old IO manager.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix potential spaceleak in __createUUIDTempFileErrNo

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove redundant -Wno-missing-signatures pragmas

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/916fc861520615149c66c1069f6cb661bc8b8483">916fc861</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Make it explicit that we only create one IO manager

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Note why we don't use blocking waits.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove commented out pragma

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove redundant buffer write in Handle/Text.hs:bufReadEmpty

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Rename SmartHandles to StdHandles

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: add comment stating failure behaviour for getUniqueFileInfo.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12846b85a94b2b73f456e4c441c7890d685deb67">12846b85</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update IOPort haddocks.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Add a note cross reference

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/62dd5a7309f273b5bb7d6ab44a1d2745010c13a0">62dd5a73</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Name Haskell/OS I/O Manager explicitly in Note

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Expand BlockedOnIOCompletion description.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove historical todos

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Update note, remove debugging pragma.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: flushCharReadBuffer shouldn't need to adjust offsets.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Remove obsolete comment about cond. variables

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix initial linux validate build

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix ThreadDelay001 CPP

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix openFile009 merge conflict leftover

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/849e8889fe9586bf9e1bf37885537f25743383f2">849e8889</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Accept T9681 output.

GHC now reports String instead of [Char].

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix cabal006 after upgrading cabal submodule

Demand cabal 2.0 syntax instead of >= 1.20 as required by newer cabal versions.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix stderr output for ghci/linking/dyn tests.

We used to filter rtsopts, i opted to instead just accept the warning of it having no effect.

This works both for -rtsopts, as well as -with-rtsopts which winio adds.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/515d98960d3cdcdd7d78a9f28d1b0ad39865c67f">515d9896</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Adjust T15261b stdout for --io-manager flag.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/949aaaccf34ef7e28a745081775b01627590fc46">949aaacc</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Adjust T5435_dyn_asm stderr

The warning about rtsopts having no consequences is expected.

So accept new stderr.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Also accept T7037 stderr

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix cabal04 by filtering rts args

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/981a9f2e57728cdf39de9fc173b11be4084997d3">981a9f2e</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix cabal01 by accepting expected stderr

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix safePkg01 by accepting expected stderr

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32734b29cbe0450d27fa6b4ea67b05aff2c4919d">32734b29</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix T5435_dyn_gcc by accepting expected stderr

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix tempfiles test on linux

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Accept accepted stderr for T3807

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Accept accepted stderr for linker_unload

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Accept accepted stderr for linker_unload_multiple_objs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67afb03c45cf8a8dc9e51413cf187f36768a5a0b">67afb03c</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: clarify wording on conditional variables.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: clarify comment on cooked mode.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: update lockfile signature and remove mistaken symbol in rts.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2143c49273d7d87ee2f3ef1211856d60b1427af1">2143c492</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-15T16:41:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add winio and winio_threaded ways

Reverts many of the testsuite changes

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-16T10:56:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Merge remote-tracking branch 'origin/wip/winio'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/750a1595ef31cdc335f3bab045b2f19a9c43ff93">750a1595</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-18T07:26:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add --copying-gc flag to reverse effect of --nonmoving-gc

Fixes #18281.

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-18T07:26:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement `fullCompilerVersion`

Follow-up of https://gitlab.haskell.org/ghc/ghc/-/issues/18403

This MR adds `fullCompilerVersion`, a function that shares the same

backend as the `--numeric-version` GHC flag, exposing a full,

three-digit version datatype.

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-07-18T07:26:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a Lint hadrian rule and an .hlint.yaml file in base/

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-18T07:26:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow multiple case branches to have a higher rank type

As #18412 points out, it should be OK for multiple case alternatives

to have a higher rank type, provided they are all the same.

This patch implements that change.  It sweeps away

GHC.Tc.Gen.Match.tauifyMultipleBranches, and friends, replacing it

with an enhanced version of fillInferResult.

The basic change to fillInferResult is to permit the case in which

another case alternative has already filled in the result; and in

that case simply unify.  It's very simple actually.

See the new Note [fillInferResult] in TcMType

Other refactoring:

- Move all the InferResult code to one place, in GHC.Tc.Utils.TcMType

  (previously some of it was in Unify)

- Move tcInstType and friends from TcMType to Instantiate, where it

  more properly belongs.  (TCMType was getting very long.)

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-18T07:26:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve typechecking of NPlusK patterns

This patch (due to Richard Eisenberg) improves

documentation of the wrapper returned by tcSubMult

(see Note [Wrapper returned from tcSubMult] in

 GHC.Tc.Utils.Unify).

And, more substantially, it cleans up the multiplicity

handling in the typechecking of NPlusKPat

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12f9035200424ec8104484f154a040d612fee99d">12f90352</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-18T07:26:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove {-# CORE #-} pragma (part of #18048)

This pragma has no effect since 2011.

It was introduced for External Core, which no longer exists.

Updates haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-18T07:26:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor the simplification of join binders

This MR (for #18449) refactors the Simplifier's treatment

of join-point binders.

Specifically, it puts together, into

     GHC.Core.Opt.Simplify.Env.adjustJoinPointType

two currently-separate ways in which we adjust the type of

a join point. As the comment says:

-- (adjustJoinPointType mult new_res_ty join_id) does two things:

--

--   1. Set the return type of the join_id to new_res_ty

--      See Note [Return type for join points]

--

--   2. Adjust the multiplicity of arrows in join_id's type, as

--      directed by 'mult'. See Note [Scaling join point arguments]

I think this actually fixes a latent bug, by ensuring that the

seIdSubst and seInScope have the right multiplicity on the type

of join points.

I did some tidying up while I was at it.  No more

setJoinResTy, or modifyJoinResTy: instead it's done locally in

Simplify.Env.adjustJoinPointType

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/49b265f08c7ac9c9dea6cfff0d67447728b7b416">49b265f0</a></strong>

<div>

<span>by Chaitanya Koparkar</span>

<i>at 2020-07-18T07:26:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix minor typos in a Core.hs note

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-18T07:26:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GHCi: Fix isLittleEndian

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-18T07:26:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark ghci tests as fragile under unreg compiler

In particular I have seen T16012 fail repeatedly under the

unregisterised compiler.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/868e452340ade3155dd7e552c16bbb3c21c42b8a">868e4523</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-20T04:30:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revert "AArch32 symbols only on aarch32."

This reverts commit cdfeb3f24f76e8fd30452016676e56fbc827789a.

Signed-off-by: Moritz Angermann <moritz.angermann@gmail.com>

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-20T04:30:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revert "Fix (1)"

This reverts commit 7abffced01f5680efafe44f6be2733eab321b039.

Signed-off-by: Moritz Angermann <moritz.angermann@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/777c452a83ebdb2b50f3f328255a6f36ae49f398">777c452a</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-20T04:30:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revert "better if guards."

This reverts commit 3f60b94de1f460ca3f689152860b108a19ce193e.

Signed-off-by: Moritz Angermann <moritz.angermann@gmail.com>

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-20T04:30:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revert "[linker/rtsSymbols] More linker symbols"

This reverts commit 686e72253aed3880268dd6858eadd8c320f09e97.

Signed-off-by: Moritz Angermann <moritz.angermann@gmail.com>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/30caeee75193ea961c55ee847a3156e23116e84e">30caeee7</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-21T06:39:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: remove use of sdocWithDynFlags from GHC.Stg.* (#17957)

* add StgPprOpts datatype

* remove Outputable instances for types that need `StgPprOpts` to be

  pretty-printed and explicitly call type specific ppr functions

* add default `panicStgPprOpts` for panic messages (when it's not

  convenient to thread StgPprOpts or DynFlags down to the ppr function

  call)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/863c544c9849e49872acac64b8faea56a3311564">863c544c</a></strong>

<div>

<span>by Mark</span>

<i>at 2020-07-21T06:39:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a typo in existential_quantification.rst</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/05910be1ac5c1f485132d2c8bd1ceb4f86e06db5">05910be1</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-21T14:47:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add release notes entry for #17816

[skip ci]

</pre>

</li>

<li>

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

<div>

<span>by Matthew Pickering</span>

<i>at 2020-07-21T14:47:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use a newtype `Code` for the return type of typed quotations (Proposal #195)

There are three problems with the current API:

1. It is hard to properly write instances for ``Quote m => m (TExp a)`` as the type is the composition

   of two type constructors. Doing so in your program involves making your own newtype and

   doing a lot of wrapping/unwrapping.

   For example, if I want to create a language which I can either run immediately or

   generate code from I could write the following with the new API. ::

      class Lang r where

        _int :: Int -> r Int

        _if  :: r Bool -> r a -> r a -> r a

      instance Lang Identity where

        _int = Identity

        _if (Identity b) (Identity t) (Identity f) = Identity (if b then t else f)

      instance Quote m => Lang (Code m) where

        _int = liftTyped

        _if cb ct cf = [|| if $$cb then $$ct else $$cf ||]

2. When doing code generation it is common to want to store code fragments in

   a map. When doing typed code generation, these code fragments contain a

   type index so it is desirable to store them in one of the parameterised

   map data types such as ``DMap`` from ``dependent-map`` or ``MapF`` from

   ``parameterized-utils``.

   ::

      compiler :: Env -> AST a -> Code Q a

      data AST a where ...

      data Ident a = ...

      type Env = MapF Ident (Code Q)

      newtype Code m a = Code (m (TExp a))

   In this example, the ``MapF`` maps an ``Ident String`` directly to a ``Code Q String``.

   Using one of these map types currently requires creating your own newtype and constantly

   wrapping every quotation and unwrapping it when using a splice. Achievable, but

   it creates even more syntactic noise than normal metaprogramming.

3. ``m (TExp a)`` is ugly to read and write, understanding ``Code m a`` is

   easier. This is a weak reason but one everyone

   can surely agree with.

Updates text submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58235d46bd4e9fbf69bd82969b29cd9c6ab051e1">58235d46</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-21T14:47:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Fix :rts-flag:`--copying-gc` documentation

It was missing a newline.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-07-21T14:50:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Accumulate Haddock comments in P (#17544, #17561, #8944)

Haddock comments are, first and foremost, comments. It's very annoying

to incorporate them into the grammar. We can take advantage of an

important property: adding a Haddock comment does not change the parse

tree in any way other than wrapping some nodes in HsDocTy and the like

(and if it does, that's a bug).

This patch implements the following:

* Accumulate Haddock comments with their locations in the P monad.

  This is handled in the lexer.

* After parsing, do a pass over the AST to associate Haddock comments

  with AST nodes using location info.

* Report the leftover comments to the user as a warning (-Winvalid-haddock).

</pre>

</li>

<li>

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

<div>

<span>by David Binder</span>

<i>at 2020-07-22T20:17:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix dead link to haskell prime discussion

</pre>

</li>

<li>

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

<div>

<span>by BinderDavid</span>

<i>at 2020-07-22T20:17:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace broken links to old haskell-prime site by working links to gitlab instance.

[skip ci]

</pre>

</li>

<li>

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

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove length field from FastString

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1010c33bb8704fa55a82bc2601d5cae2e6ecc21f">1010c33b</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use ShortByteString for FastString

There are multiple reasons we want this:

- Fewer allocations: ByteString has 3 fields, ShortByteString just has one.

- ByteString memory is pinned:

  - This can cause fragmentation issues (see for example #13110) but also

  - makes using FastStrings in compact regions impossible.

Metric Decrease:

    T5837

    T12150

    T12234

    T12425

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8336ba78e00ec42521ba8314bc65ec766e6bcc7d">8336ba78</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pass specialised utf8DecodeChar# to utf8DecodeLazy# for performance

Currently we're passing a indexWord8OffAddr# type function to

utf8DecodeLazy# which then passes it on to utf8DecodeChar#. By passing one

of utf8DecodeCharAddr# or utf8DecodeCharByteArray# instead we benefit from

the inlining and specialization already done for those.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7484a9a47ad277bb7e51c6357817f7e7c59e744a">7484a9a4</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Encoding: Add comment about tricky ForeignPtr lifetime

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5536ed28b676106810e65bac15305ad2b1b0babd">5536ed28</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use IO constructor instead of `stToIO . ST`

</pre>

</li>

<li>

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

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Encoding: Remove redundant use of withForeignPtr

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5976a1614e3da7d77f624103bb67f602738e93b8">5976a161</a></strong>

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Encoding: Reformat utf8EncodeShortByteString to be more consistent

</pre>

</li>

<li>

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

<div>

<span>by Daniel Gröber</span>

<i>at 2020-07-22T20:18:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">FastString: Reintroduce character count cache

Metric Increase:

    ManyConstructors

Metric Decrease:

    T4029

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-22T20:18:46-04:00</i>

</div>

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

This fixes the error message given by configure when the user

attempts to configure without first download the win32 tarballs.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-22T20:19:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable BangPatterns, ScopedTypeVariables for ghc and hadrian by default.

This is only for their respective codebases.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

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

This flag has been removed in 066b369de2c6f7da03c88206288dca29ab061b31

in 2011.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't panic if the NCG isn't built (it is always built)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Correctly test active backend

Previously we used a platform settings to detect if the native code

generator was used. This was wrong. We need to use the

`DynFlags.hscTarget` field instead.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/735f9d6bac316a0c1c68a8b49bba465f07b01cdd">735f9d6b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace ghcWithNativeCodeGen with a proper Backend datatype

* Represent backends with a `Backend` datatype in GHC.Driver.Backend

* Don't detect the default backend to use for the target platform at

  compile time in Hadrian/make but at runtime. It makes "Settings"

  simpler and it is a step toward making GHC multi-target.

* The latter change also fixes hadrian which has not been updated to

  take into account that the NCG now supports AIX and PPC64 (cf

  df26b95559fd467abc0a3a4151127c95cb5011b9 and

  d3c1dda60d0ec07fc7f593bfd83ec9457dfa7984)

* Also we don't treat iOS specifically anymore (cf

  cb4878ffd18a3c70f98bdbb413cd3c4d1f054e1f)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:19:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace HscTarget with Backend

They both have the same role and Backend name is more explicit.

Metric Decrease:

    T3064

Update Haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15ce1804d2b87ac7bd55632957a4cb897decbbee">15ce1804</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-07-22T20:20:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Deprecate -fdmd-tx-dict-sel.

It's behaviour is now unconditionally enabled as

it's slightly beneficial.

There are almost no benchmarks which benefit from

disabling it, so it's not worth the keep this

configurable.

This fixes #18429.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:21:11-04:00</i>

</div>

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

It has been fixed by 0effc57d48ace6b719a9f4cbeac67c95ad55010b

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-22T20:21:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define type Void# = (# #) (#18441)

There's one backwards compatibility issue: GHC.Prim no longer exports

Void#, we now manually re-export it from GHC.Exts.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/02f40b0da2eadbf8a0e2930b95d4cef686acd92f">02f40b0d</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-07-22T20:22:23-04:00</i>

</div>

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

!3392 backported !2993 to GHC 8.10.2 which most probably is responsible

for fixing #18478, which triggered a pattern match checker performance

regression in GHC 8.10.1 as first observed in #17977.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-22T20:23:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Minor refactoring of Unit display

* for consistency, try to always use UnitPprInfo to display units to

  users

* remove some uses of `unitPackageIdString` as it doesn't show the

  component name and it uses String

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-07-23T07:55:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[linker] Fix out of range relocations.

mmap may return address all over the place. mmap_next will ensure we get

the next free page after the requested address.

This is especially important for linking on aarch64, where the memory model with PIC

admits relocations in the +-4GB range, and as such we can't work with

arbitrary object locations in memory.

Of note: we map the rts into process space, so any mapped objects must

not be ouside of the 4GB from the processes address space.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-24T18:12:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: restore console cp on exit

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-24T18:13:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: change memory allocation strategy and fix double free errors.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-24T18:13:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Care with occCheckExpand in kind of occurrences

Issue #18451 showed that we could get an infinite type, through

over-use of occCheckExpand in the kind of an /occurrence/ of a

type variable.

See Note [Occurrence checking: look inside kinds] in GHC.Core.Type

This patch fixes the problem by making occCheckExpand less eager

to expand synonyms in kinds.

It also improves pretty printing of kinds, by *not* suppressing

the kind on a tyvar-binder like

    (a :: Const Type b)

where type Const p q = p.  Even though the kind of 'a' is Type,

we don't want to suppress the kind ascription.  Example: the

error message for polykinds/T18451{a,b}. See GHC.Core.TyCo.Ppr

Note [Suppressing * kinds].

</pre>

</li>

<li>

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

<div>

<span>by Zubin Duggal</span>

<i>at 2020-07-25T00:44:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify XRec definition

Change `Located X` usage to `XRec pass X`

This increases the scope of the LPat experiment to almost all of GHC.

Introduce UnXRec and MapXRec classes

Fixes #17587 and #18408

Updates haddock submodule

Co-authored-by: Philipp Krüger <philipp.krueger1@gmail.com>

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: store printer in TraceBinIfaceReading

We don't need to pass the whole DynFlags, just pass the logging

function, if any.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15b2b44fe35292dc3ac93ec215c44fba42165f67">15b2b44f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename GHC.Driver.Ways into GHC.Platform.Ways

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/342a01af624840ba94f22256079ff4f3cee09ca2">342a01af</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add GHC.Platform.Profile

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6333d7391068d8029eed3e8eff019b9e2c104c7b">6333d739</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Put PlatformConstants into Platform

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove platform constant wrappers

Platform constant wrappers took a DynFlags parameter, hence implicitly

used the target platform constants. We removed them to allow support

for several platforms at once (#14335) and to avoid having to pass

the full DynFlags to every function (#17957).

Metric Decrease:

   T4801

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/73145d57f961c73b5853da7881d6a21e48e05909">73145d57</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove dead code in utils/derivConstants

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7721b923d53fb9eb93f80bb93b4c3bd976c05b4c">7721b923</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move GHC.Platform into the compiler

Previously it was in ghc-boot so that ghc-pkg could use it. However it

wasn't necessary because ghc-pkg only uses a subset of it: reading

target arch and OS from the settings file. This is now done via

GHC.Platform.ArchOS (was called PlatformMini before).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/459afeb592d5ff6d338184f5ef248758ecda57a4">459afeb5</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix build systems

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-25T00:45:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add accessors to ArchOS

</pre>

</li>

<li>

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

<div>

<span>by Stefan Schulze Frielinghaus</span>

<i>at 2020-07-25T00:45:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Require SMP support in order to build a threaded stage1

Fixes 18266

</pre>

</li>

<li>

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

<div>

<span>by Matthias Andreas Benkard</span>

<i>at 2020-07-26T13:23:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document loadFramework changes. (#18446)

Adds commentary on the rationale for the changes made in merge request

!3689.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-26T13:23:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/win32: Exit with EXIT_HEAPOVERFLOW if memory commit fails

Since switching to the two-step allocator, the `outofmem` test fails via

`osCommitMemory` failing to commit. However, this was previously exiting

with `EXIT_FAILURE`, rather than `EXIT_HEAPOVERFLOW`. I think the latter

is a more reasonable exit code for this case and matches the behavior on

POSIX platforms.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-26T13:23:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Update win32 output for parseTree

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-26T13:23:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Normalise WinIO error message differences

Previously the old Windows IO manager threw different errors than WinIO.

We now canonicalise these to the WinIO errors.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-26T13:23:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Kill ssh-agent after pushing test metrics

Otherwise the Windows builds hang forever waiting for the process to

terminate.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-26T13:24:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: remove dead argument to stg_newIOPortzh

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-26T13:25:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix detection of tty terminals

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/52685cf7c077c51e3719e3c4dd5ca8257a99c4ea">52685cf7</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-07-26T13:25:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: update codeowners

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-07-27T07:06:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve NegativeLiterals (#18022, GHC Proposal #344)

Before this patch, NegativeLiterals used to parse x-1 as x (-1).

This may not be what the user expects, and now it is fixed:

x-1 is parsed as (-) x 1.

We achieve this by the following requirement:

  * When lexing a negative literal,

    it must not be preceded by a 'closing token'.

This also applies to unboxed literals, e.g. -1#.

See GHC Proposal #229 for the definition of a closing token.

A nice consequence of this change is that -XNegativeLiterals becomes a

subset of -XLexicalNegation. In other words, enabling both of those

extensions has the same effect as enabling -XLexicalNegation alone.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/667ab69e5edacb2ce2f42fb810cd54c8f856d30b">667ab69e</a></strong>

<div>

<span>by leiftw</span>

<i>at 2020-07-27T07:07:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix typo referring to non-existent `-ohidir` flag, should be `-hidir` I think</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-07-27T07:08:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor the parser a little

* Create a dedicated production for type operators

* Create a dedicated type for the UNPACK pragma

* Remove an outdated part of Note [Parsing data constructors is hard]

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Drop 32-bit Windows support

As noted in #18487, we have reached the end of this road.

</pre>

</li>

<li>

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

<div>

<span>by Michalis Pardalos</span>

<i>at 2020-07-27T20:09:44-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/47680cb76b068508fd16d052e0a3bed12e38ea5f">47680cb7</a></strong>

<div>

<span>by Michalis Pardalos</span>

<i>at 2020-07-27T20:09:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use allocate, not ALLOC_PRIM_P for unpackClosure#

ALLOC_PRIM_P fails for large closures, by directly using allocate

we can handle closures which are larger than the block size.

Fixes #12492

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-27T20:10:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Eta-expand the Simplifier monad

This patch eta-expands the Simplifier's monad, using the method

explained in GHC.Core.Unify Note [The one-shot state monad trick].

It's part of the exta-expansion programme in #18202.

It's a tiny patch, but is worth a 1-2% reduction in bytes-allocated

by the compiler.  Here's the list, based on the compiler-performance

tests in perf/compiler:

                    Reduction in bytes allocated

   T10858(normal)      -0.7%

   T12425(optasm)      -1.3%

   T13056(optasm)      -1.8%

   T14683(normal)      -1.1%

   T15164(normal)      -1.3%

   T15630(normal)      -1.4%

   T17516(normal)      -2.3%

   T18282(normal)      -1.6%

   T18304(normal)      -0.8%

   T1969(normal)       -0.6%

   T4801(normal)       -0.8%

   T5321FD(normal)     -0.7%

   T5321Fun(normal)    -0.5%

   T5642(normal)       -0.9%

   T6048(optasm)       -1.1%

   T9020(optasm)       -2.7%

   T9233(normal)       -0.7%

   T9675(optasm)       -0.5%

   T9961(normal)       -2.9%

   WWRec(normal)       -1.2%

Metric Decrease:

    T12425

    T9020

    T9961

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57aca6bba1c000f8542ce94e8b724b0334ff96d4">57aca6bb</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-27T20:10:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Ensure that Hadrian jobs don't download artifacts

Previously the Hadrian jobs had the default dependencies, meaning that

they would download artifacts from all jobs of earlier stages. This is

unneccessary.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-07-27T20:10:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump bootstrap compiler to 8.8.4

Hopefully this will make the Windows jobs a bit more reliable.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-28T02:01:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">This patch addresses the exponential blow-up in the simplifier.

Specifically:

  #13253 exponential inlining

  #10421 ditto

  #18140 strict constructors

  #18282 another nested-function call case

This patch makes one really significant changes: change the way that

mkDupableCont handles StrictArg.  The details are explained in

GHC.Core.Opt.Simplify Note [Duplicating StrictArg].

Specific changes

* In mkDupableCont, when making auxiliary bindings for the other arguments

  of a call, add extra plumbing so that we don't forget the demand on them.

  Otherwise we haev to wait for another round of strictness analysis. But

  actually all the info is to hand.  This change affects:

  - Make the strictness list in ArgInfo be [Demand] instead of [Bool],

    and rename it to ai_dmds.

  - Add as_dmd to ValArg

  - Simplify.makeTrivial takes a Demand

  - mkDupableContWithDmds takes a [Demand]

There are a number of other small changes

1. For Ids that are used at most once in each branch of a case, make

   the occurrence analyser record the total number of syntactic

   occurrences.  Previously we recorded just OneBranch or

   MultipleBranches.

   I thought this was going to be useful, but I ended up barely

   using it; see Note [Note [Suppress exponential blowup] in

   GHC.Core.Opt.Simplify.Utils

   Actual changes:

     * See the occ_n_br field of OneOcc.

     * postInlineUnconditionally

2. I found a small perf buglet in SetLevels; see the new

   function GHC.Core.Opt.SetLevels.hasFreeJoin

3. Remove the sc_cci field of StrictArg.  I found I could get

   its information from the sc_fun field instead.  Less to get

   wrong!

4. In ArgInfo, arrange that ai_dmds and ai_discs have a simpler

   invariant: they line up with the value arguments beyond ai_args

   This allowed a bit of nice refactoring; see isStrictArgInfo,

   lazyArgcontext, strictArgContext

There is virtually no difference in nofib. (The runtime numbers

are bogus -- I tried a few manually.)

        Program           Size    Allocs   Runtime   Elapsed  TotalMem

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

            fft          +0.0%     -2.0%    -48.3%    -49.4%      0.0%

     multiplier          +0.0%     -2.2%    -50.3%    -50.9%      0.0%

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

            Min          -0.4%     -2.2%    -59.2%    -60.4%      0.0%

            Max          +0.0%     +0.1%     +3.3%     +4.9%      0.0%

 Geometric Mean          +0.0%     -0.0%    -33.2%    -34.3%     -0.0%

Test T18282 is an existing example of these deeply-nested strict calls.

We get a big decrease in compile time (-85%) because so much less

inlining takes place.

Metric Decrease:

    T18282

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-28T02:02:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add support for negative shifts (fix #18499)

shiftR/shiftL support negative arguments despite Haskell 2010 report

saying otherwise. We explicitly test for negative values which is bad

(it gets in the way of constant folding, etc.). Anyway, for consistency

we fix Bits instancesof Integer/Natural.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-07-28T02:03:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">config: Fix Haskell platform constructor w/ params

Fixes #18505

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/318bb17c9d3fbbe68eff706c38eb8e653cea3d83">318bb17c</a></strong>

<div>

<span>by Oleg Grenrus</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typo in haddock

Spotted by `vilpan` on `#haskell`

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/39c89862161bf488a6aca9372cbb67690f436ce7">39c89862</a></strong>

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-07-28T20:54:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc/mk: don't build gmp packages for BIGNUM_BACKEND=native

Before this change make-based `BIGNUM_BACKEND=native` build was failing as:

```

x86_64-pc-linux-gnu-gcc: error: libraries/ghc-bignum/gmp/objs/*.o: No such file or directory

```

This happens because ghc.mk was pulling in gmp-dependent

ghc-bignum library unconditionally. The change avoid building

ghc-bignum.

Bug: https://gitlab.haskell.org/ghc/ghc/-/issues/18437

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

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

<div>

<span>by Felix Wiemuth</span>

<i>at 2020-07-29T15:06:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typo</pre>

</li>

<li>

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

<div>

<span>by Brandon Chinn</span>

<i>at 2020-07-29T15:07:11-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Brandon Chinn</span>

<i>at 2020-07-29T15:07:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pass dit_rep_tc_args to dsm_stock_gen_fn

</pre>

</li>

<li>

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

<div>

<span>by Brandon Chinn</span>

<i>at 2020-07-29T15:07:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pass tc_args to gen_fn

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/44b11bad052eabf43246acba6aab814376b08713">44b11bad</a></strong>

<div>

<span>by Brandon Chinn</span>

<i>at 2020-07-29T15:07:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Filter out unreachable constructors when deriving stock instances (#16431)

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-29T15:07:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Kill off sc_mult and as_mult fields

They are readily derivable from other fields, so this is more

efficient, and less error prone.

Fixes #18494

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Fix build system on ARM

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/96c31ea1f0303ebabc59edccff2e88444fe02722">96c31ea1</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-29T15:09:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix bug in Natural multiplication (fix #18509)

A bug was lingering in Natural multiplication (inverting two limbs)

despite QuickCheck tests used during the development leading to wrong

results (independently of the selected backend).

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-07-29T15:09:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix validation errors (#18510)

Test T2632 is a stage1 test that failed because of the Q => Quote change.

The remaining tests did not use quotation and failed when the path

contained a space.

</pre>

</li>

<li>

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

<div>

<span>by John Ericson</span>

<i>at 2020-07-30T07:11:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">For `-fkeep-going` do not duplicate dependency edge code

We now compute the deps for `-fkeep-going` the same way that the

original graph calculates them, so the edges are correct. Upsweep really

ought to take the graph rather than a topological sort so we are never

recalculating anything, but at least things are recaluclated

consistently now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/502de55676a38572db60848c13392f5f115e1c8a">502de556</a></strong>

<div>

<span>by cgibbard</span>

<i>at 2020-07-30T07:11:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add haddock comment for unfilteredEdges

and move the note about drop_hs_boot_nodes into it.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01c948eba4bea2d2c8ad340e12c1e7b732b334f7">01c948eb</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-30T07:11:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up the inferred type variable restriction

This patch primarily:

* Documents `checkInferredVars` (previously called

  `check_inferred_vars`) more carefully. This is the

  function which throws an error message if a user quantifies an

  inferred type variable in a place where specificity cannot be

  observed. See `Note [Unobservably inferred type variables]` in

  `GHC.Rename.HsType`.

  Note that I now invoke `checkInferredVars` _alongside_

  `rnHsSigType`, `rnHsWcSigType`, etc. rather than doing so _inside_

  of these functions. This results in slightly more call sites for

  `checkInferredVars`, but it makes it much easier to enumerate the

  spots where the inferred type variable restriction comes into

  effect.

* Removes the inferred type variable restriction for default method

  type signatures, per the discussion in #18432. As a result, this

  patch fixes #18432.

Along the way, I performed some various cleanup:

* I moved `no_nested_foralls_contexts_err` into `GHC.Rename.Utils`

  (under the new name `noNestedForallsContextsErr`), since it now

  needs to be invoked from multiple modules. I also added a helper

  function `addNoNestedForallsContextsErr` that throws the error

  message after producing it, as this is a common idiom.

* In order to ensure that users cannot sneak inferred type variables

  into `SPECIALISE instance` pragmas by way of nested `forall`s, I

  now invoke `addNoNestedForallsContextsErr` when renaming

  `SPECIALISE instance` pragmas, much like when we rename normal

  instance declarations. (This probably should have originally been

  done as a part of the fix for #18240, but this task was somehow

  overlooked.) As a result, this patch fixes #18455 as a side effect.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-07-30T07:12:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't mark closed type family equations as occurrences

Previously, `rnFamInstEqn` would mark the name of the type/data

family used in an equation as an occurrence, regardless of what sort

of family it is. Most of the time, this is the correct thing to do.

The exception is closed type families, whose equations constitute its

definition and therefore should not be marked as occurrences.

Overzealously counting the equations of a closed type family as

occurrences can cause certain warnings to not be emitted, as observed

in #18470.  See `Note [Type family equations and occurrences]` in

`GHC.Rename.Module` for the full story.

This fixes #18470 with a little bit of extra-casing in

`rnFamInstEqn`. To accomplish this, I added an extra

`ClosedTyFamInfo` field to the `NonAssocTyFamEqn` constructor of

`AssocTyFamInfo` and refactored the relevant call sites accordingly

so that this information is propagated to `rnFamInstEqn`.

While I was in town, I moved `wrongTyFamName`, which checks that the

name of a closed type family matches the name in an equation for that

family, from the renamer to the typechecker to avoid the need for an

`ASSERT`. As an added bonus, this lets us simplify the details of

`ClosedTyFamInfo` a bit.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-07-30T07:12:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove an incorrect WARN in extendLocalRdrEnv

I noticed this warning going off, and discovered that it's

really fine.  This small patch removes the warning, and docments

what is going on.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add two bangs to improve perf of flattening

This tiny patch improves the compile time of flatten-heavy

programs by 1-2%, by adding two bangs.

Addresses (somewhat) #18502

This reduces allocation by

   T9872b   -1.1%

   T9872d   -3.3%

   T5321Fun -0.2%

   T5631    -0.2%

   T5837    +0.1%

   T6048    +0.1%

Metric Decrease:

    T9872b

    T9872d

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-30T22:54:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix minimal imports dump for boot files (fix #18497)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/175cb5b4044e6f4ad2224f54115f42e7a8b08f9b">175cb5b4</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-30T22:55:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: don't use sdocWithDynFlags in datacon ppr

We don't need to use `sdocWithDynFlags` to know whether we should

display linear types for datacon types, we already have

`sdocLinearTypes` field in `SDocContext`.  Moreover we want to remove

`sdocWithDynFlags` (#10143, #17957)).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/380638a33691ba43fdcd2e18bca636750e5f66f1">380638a3</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-30T22:56:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: fix powMod for gmp backend (#18515)

Also reenable integerPowMod test which had never been reenabled by

mistake.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/56a7c19337c5b2aa21d521a6d7c965174ec8379b">56a7c193</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-31T19:32:09+02:00</i>

</div>

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

Pretty-printing CLabel relies on sdocWithDynFlags that we want to remove

(#10143, #17957). It uses it to query the backend and the platform.

This patch exposes Clabel ppr functions specialised for each backend so

that backend code can directly use them.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-07-31T19:32:09+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: don't use sdocWithDynFlags in GHC.CmmToAsm.Dwarf.Types

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-01T04:23:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Test case for #17652

The issue was fixed by 19e80b9af252eee760dc047765a9930ef00067ec

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/226417424b2b578fd3c5424588367cb24e7720eb">22641742</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-08-02T16:44:11-04:00</i>

</div>

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

This removes the `ConDeclGADTPrefixPs` per the discussion in #18517.

Most of this patch simply removes code, although the code in the

`rnConDecl` case for `ConDeclGADTPrefixPs` had to be moved around a

bit:

* The nested `forall`s check now lives in the `rnConDecl` case for

  `ConDeclGADT`.

* The `LinearTypes`-specific code that used to live in the

  `rnConDecl` case for `ConDeclGADTPrefixPs` now lives in

  `GHC.Parser.PostProcess.mkGadtDecl`, which is now monadic so that

  it can check if `-XLinearTypes` is enabled.

Fixes #18157.

</pre>

</li>

<li>

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

<div>

<span>by Leon Schoorl</span>

<i>at 2020-08-02T16:44:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix GHC_STAGE definition generated by make

Fixes #18070

GHC_STAGE is the stage of the compiler we're building, it should be 1,2(,3?).

But make was generating 0 and 1.

Hadrian does this correctly using a similar `+ 1`:

https://gitlab.haskell.org/ghc/ghc/-/blob/eb8115a8c4cbc842b66798480fefc7ab64d31931/hadrian/src/Rules/Generate.hs#L245

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/947206f478d4eef641dfc58cb4c13471a23260c3">947206f4</a></strong>

<div>

<span>by Niklas Hambüchen</span>

<i>at 2020-08-03T07:52:33+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fix running stage0/bin/ghc with wrong package DB. Fixes #17468.

In the invocation of `cabal configure`, `--ghc-pkg-option=--global-package-db`

was already given correctly to tell `stage0/bin/ghc-pkg` that it should use

the package DB in `stage1/`.

However, `ghc` needs to be given this information as well, not only `ghc-pkg`!

Until now that was not the case; the package DB in `stage0` was given to

`ghc` instead.

This was wrong, because there is no binary compatibility guarantee that says

that the `stage0` DB's `package.cache` (which is written by the

stage0 == system-provided ghc-pkg) can be deserialised by the `ghc-pkg`

from the source code tree.

As a result, when trying to add fields to `InstalledPackageInfo` that get

serialised into / deserialised from the `package.cache`, errors like

    _build/stage0/lib/package.conf.d/package.cache: GHC.PackageDb.readPackageDb: inappropriate type (Not a valid Unicode code point!)

would appear. This was because the `stage0/bin/ghc would try to

deserialise the newly added fields from

`_build/stage0/lib/package.conf.d/package.cache`, but they were not in there

because the system `ghc-pkg` doesn't know about them and thus didn't write them

there.

It would try to do that because any GHC by default tries to read the global

package db in `../lib/package.conf.d/package.cache`.

For `stage0/bin/ghc` that *can never work* as explained above, so we

must disable this default via `-no-global-package-db` and give it the

correct package DB explicitly.

This is the same problem as #16534, and the same fix as in MR !780

(but in another context; that one was for developers trying out the

`stage0/bin/ghc` == `_build/ghc-stage1` interactively, while this fix

is for a `cabal configure` invocation).

I also noticed that the fix for #16534 forgot to pass `-no-global-package-db`,

and have fixed that in this commit as well.

It only worked until now because nobody tried to add a new ghc-pkg `.conf`

field since the introduction of Hadrian.

</pre>

</li>

<li>

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

<div>

<span>by Alex Biehl</span>

<i>at 2020-08-03T07:52:33+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hardcode RTS includes to cope with unregistered builds

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-05T03:59:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add backward compat integer-gmp functions

Also enhance bigNatCheck# and isValidNatural test

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-05T03:59:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add more BigNat compat functions in integer-gmp

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename Core.Opt.Driver -> Core.Opt.Pipeline

Closes #18504.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Revert "iserv: Don't pass --export-dynamic on FreeBSD"

This reverts commit 2290eb02cf95e9cfffcb15fc9c593d5ef79c75d9.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/53ce0db5a06598c88c6b8cb32043b878e7083dd4">53ce0db5</a></strong>

<div>

<span>by Ben Gamari</span>

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

</div>

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

Previously to merge a set of object files we would invoke the linker as

usual, adding -r to the command-line. However, this can result in

non-sensical command-lines which causes lld to balk (#17962).

To avoid this we introduce a new tool setting into GHC, -pgmlm, which is

the linker which we use to merge object files.

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-08-05T04:01:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove all the unnecessary LANGUAGE pragmas

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-08-05T04:01:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make CodeQ and TExpQ levity polymorphic

The patch is quite straightforward. The only tricky part is that

`Language.Haskell.TH.Lib.Internal` now must be `Trustworthy` instead

of `Safe` due to the `GHC.Exts` import (in order to import `TYPE`).

Since `CodeQ` has yet to appear in any released version of

`template-haskell`, I didn't bother mentioning the change to `CodeQ`

in the `template-haskell` release notes.

Fixes #18521.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/686e06c59c3aa6b66895e8a501c7afb019b09e36">686e06c5</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-06T13:34:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Grammar for types and data/newtype constructors

Before this patch, we parsed types into a reversed sequence

of operators and operands. For example, (F x y + G a b * X)

would be parsed as [X, *, b, a, G, +, y, x, F],

using a simple grammar:

        tyapps

          : tyapp

          | tyapps tyapp

        tyapp

          : atype

          | PREFIX_AT atype

          | tyop

          | unpackedness

Then we used a hand-written state machine to assemble this

 either into a type,        using 'mergeOps',

     or into a constructor, using 'mergeDataCon'.

This is due to a syntactic ambiguity:

        data T1 a =          MkT1 a

        data T2 a = Ord a => MkT2 a

In T1, what follows after the = sign is a data/newtype constructor

declaration. However, in T2, what follows is a type (of kind

Constraint). We don't know which of the two we are parsing until we

encounter =>, and we cannot check for => without unlimited lookahead.

This poses a few issues when it comes to e.g. infix operators:

        data I1 = Int :+ Bool :+ Char          -- bad

        data I2 = Int :+ Bool :+ Char => MkI2  -- fine

By this issue alone we are forced into parsing into an intermediate

representation and doing a separate validation pass.

However, should that intermediate representation be as low-level as a

flat sequence of operators and operands?

Before GHC Proposal #229, the answer was Yes, due to some particularly

nasty corner cases:

        data T = ! A :+ ! B          -- used to be fine, hard to parse

        data T = ! A :+ ! B => MkT   -- bad

However, now the answer is No, as this corner case is gone:

        data T = ! A :+ ! B          -- bad

        data T = ! A :+ ! B => MkT   -- bad

This means we can write a proper grammar for types, overloading it in

the DisambECP style, see Note [Ambiguous syntactic categories].

With this patch, we introduce a new class, DisambTD. Just like

DisambECP is used to disambiguate between expressions, commands, and patterns,

DisambTD  is used to disambiguate between types and data/newtype constructors.

This way, we get a proper, declarative grammar for constructors and

types:

        infixtype

          : ftype

          | ftype tyop infixtype

          | unpackedness infixtype

        ftype

          : atype

          | tyop

          | ftype tyarg

          | ftype PREFIX_AT tyarg

        tyarg

          : atype

          | unpackedness atype

And having a grammar for types means we are a step closer to using a

single grammar for types and expressions.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6770e199645b0753d2edfddc68c199861a1be980">6770e199</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-06T13:34:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clean up the story around runPV/runECP_P/runECP_PV

This patch started as a small documentation change, an attempt to make

Note [Parser-Validator] and Note [Ambiguous syntactic categories]

more clear and up-to-date.

But it turned out that runECP_P/runECP_PV are weakly motivated,

and it's easier to remove them than to find a good rationale/explanation

for their existence.

As the result, there's a bit of refactoring in addition to

a documentation update.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/826d07db0e0f31fe2b2d2e0661be7f0cb3cde3c7">826d07db</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-06T13:34:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix debug_ppr_ty ForAllTy (#18522)

Before this change, GHC would

pretty-print   forall k. forall a -> ()

          as   forall @k a. ()

which isn't even valid Haskell.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-06T13:34:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix visible forall in ppr_ty (#18522)

Before this patch, this type:

  T :: forall k -> (k ~ k) => forall j -> k -> j -> Type

was printed incorrectly as:

  T :: forall k j -> (k ~ k) => k -> j -> Type

</pre>

</li>

<li>

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

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-08-06T13:34:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fail eagerly on a lev-poly datacon arg

Close #18534.

See commentary in the patch.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/63348155404c64334fa864454132630f9d2a4d7f">63348155</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-06T13:34:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use a type alias for Ways

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9570c21295a2b4a1d1e40939869124f0b9b9bf91">9570c212</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-06T19:46:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Rename 8.12 to 9.0

GHC 8.12.1 has been renamed to GHC 9.0.1.

See also:

  https://mail.haskell.org/pipermail/ghc-devs/2020-July/019083.html

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3907ee01e68b383fa30386d163decf203acedb19">3907ee01</a></strong>

<div>

<span>by Cale Gibbard</span>

<i>at 2020-08-07T08:34:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">A fix to an error message in monad comprehensions, and a move of dsHandleMonadicFailure

as suggested by comments on !2330.

</pre>

</li>

<li>

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

<div>

<span>by Cale Gibbard</span>

<i>at 2020-08-07T08:34:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add some tests for fail messages in do-expressions and monad-comprehensions.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T08:35:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">cmm: Clean up Notes a bit

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6402c1240d5bd768b8fe8b4368413932bedbe107">6402c124</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T08:35:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">CmmLint: Check foreign call argument register invariant

As mentioned in Note [Register parameter passing] the arguments of

foreign calls cannot refer to caller-saved registers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15b36de030ecdd60897bc7a6a02bdeabd0825be4">15b36de0</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T08:35:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen: One approach to fix #18527

Previously the code generator could produce corrupt C call sequences due

to register overlap between MachOp lowerings and the platform's calling

convention. We fix this using a hack described in Note [Evaluate C-call

arguments before placing in destination registers].

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3847ae0ccf67bddf73304a39f5320c3ba285aa48">3847ae0c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T08:35:21-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T08:35:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Fix prog001

Previously it failed as the `ghc` package was not visible.

</pre>

</li>

<li>

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

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-08-07T23:58:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ApiAnnotations; tweaks for ghc-exactprint update

Remove unused ApiAnns, add one for linear arrow.

Include API Annotations for trailing comma in export list.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-07T23:58:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Fix double-negation in ld merge-objects check

We want to only run the check if ld is gold.

Fixes the fix to #17962.</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Ericsson</span>

<i>at 2020-08-09T11:32:25+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: depend on boot compiler version #18001

</pre>

</li>

<li>

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

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-08-09T21:17:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Api Annotations : Adjust SrcSpans for prefix bang (!).

And prefix ~

(cherry picked from commit 8dbee2c578b1f642d45561be3f416119863e01eb)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/77398b678aba45ba25932a39b7e8a7a31d0dd6f3">77398b67</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-09T21:18:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid allocations in `splitAtList` (#18535)

As suspected by @simonpj in #18535, avoiding allocations in

`GHC.Utils.Misc.splitAtList` when there are no leftover arguments is

beneficial for performance:

   On CI validate-x86_64-linux-deb9-hadrian:

    T12227 -7%

    T12545 -12.3%

    T5030  -10%

    T9872a -2%

    T9872b -2.1%

    T9872c -2.5%

Metric Decrease:

    T12227

    T12545

    T5030

    T9872a

    T9872b

    T9872c

</pre>

</li>

<li>

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

<div>

<span>by Felix Yan</span>

<i>at 2020-08-10T20:23:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Correct a typo in ghc.mk</pre>

</li>

<li>

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

<div>

<span>by Felix Yan</span>

<i>at 2020-08-10T20:23:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a closing parenthesis too

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-10T20:24:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make splitAtList strict in its arguments

Also fix its slightly wrong comment

Metric Decrease:

    T5030

    T12227

    T12545

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-11T22:18:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">typecheck: Drop SPECIALISE pragmas when there is no unfolding

Previously the desugarer would instead fall over when it realized that

there was no unfolding for an imported function with a SPECIALISE

pragma. We now rather drop the SPECIALISE pragma and throw a warning.

Fixes #18118.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-11T22:18:03-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sven Tennie</span>

<i>at 2020-08-11T22:18:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add hie.yaml to ghc-heap

This enables IDE support by haskell-language-server for ghc-heap.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-11T22:19:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Specify metrics collected by T17516

Previously it collected everything, including "max bytes used". This is

problematic since the test makes no attempt to control for deviations in

GC timing, resulting in high variability. Fix this by only collecting

"bytes allocated".

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-12T03:50:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: disentangle Outputable

- put panic related functions into GHC.Utils.Panic

- put trace related functions using DynFlags in GHC.Driver.Ppr

One step closer making Outputable fully independent of DynFlags.

Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-12T03:50:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Increase tolerance of T16916

T16916 (testing #16916) has been slightly fragile in CI due to its

reliance on CPU times. While it's hard to see how to eliminate

the time-dependence entirely, we can nevertheless make it more tolerant.

Fixes #16966.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-12T20:52:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rewrite and move the monad-state hack note

The note has been rewritten by @simonpj in !3851

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/25fdf25eb574d6d291673603ab36ac5ec7e37066">25fdf25e</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-08-12T20:53:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ApiAnnotations: Fix parser for new GHC 9.0 features

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7831fe05021caa90d4696ca91ae2b31a82e65b3d">7831fe05</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-13T03:44:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">parser: Suggest ImportQualifiedPost in prepositive import warning

As suggested in #18545.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-08-13T03:44:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Better long-distance info for where bindings (#18533)

Where bindings can see evidence from the pattern match of the `GRHSs`

they belong to, but not from anything in any of the guards (which belong

to one of possibly many RHSs).

Before this patch, we did *not* consider said evidence, causing #18533,

where the lack of considering type information from a case pattern match

leads to failure to resolve the vanilla COMPLETE set of a data type.

Making available that information required a medium amount of

refactoring so that `checkMatches` can return a

`[(Deltas, NonEmpty Deltas)]`; one `(Deltas, NonEmpty Deltas)` for each

`GRHSs` of the match group. The first component of the pair is the

covered set of the pattern, the second component is one covered set per

RHS.

Fixes #18533.

Regression test case: T18533

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-08-13T03:45:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Re-add BangPatterns to CodePage.hs

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-13T09:49:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add HomeUnit type

Since Backpack the "home unit" is much more involved than what it was

before (just an identifier obtained with `-this-unit-id`). Now it is

used in conjunction with `-component-id` and `-instantiated-with` to

configure module instantiations and to detect if we are type-checking an

indefinite unit or compiling a definite one.

This patch introduces a new HomeUnit datatype which is much easier to

understand. Moreover to make GHC support several packages in the same

instances, we will need to handle several HomeUnits so having a

dedicated (documented) type is helpful.

Finally in #14335 we will also need to handle the case where we have no

HomeUnit at all because we are only loading existing interfaces for

plugins which live in a different space compared to units used to

produce target code. Several functions will have to be refactored to

accept "Maybe HomeUnit" parameters instead of implicitly querying the

HomeUnit fields in DynFlags. Having a dedicated type will make this

easier.

Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-13T21:09:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make IOEnv monad one-shot (#18202)

On CI (x86_64-linux-deb9-hadrian, compile_time/bytes_allocated):

    T10421     -1.8%    (threshold: +/- 1%)

    T10421a    -1.7%    (threshold: +/- 1%)

    T12150     -4.9%    (threshold: +/- 2%)

    T12227     -1.6     (threshold: +/- 1%)

    T12425     -1.5%    (threshold: +/- 1%)

    T12545     -3.8%    (threshold: +/- 1%)

    T12707     -3.0%    (threshold: +/- 1%)

    T13035     -3.0%    (threshold: +/- 1%)

    T14683     -10.3%   (threshold: +/- 2%)

    T3064      -6.9%    (threshold: +/- 2%)

    T4801      -4.3%    (threshold: +/- 2%)

    T5030      -2.6%    (threshold: +/- 2%)

    T5321FD    -3.6%    (threshold: +/- 2%)

    T5321Fun   -4.6%    (threshold: +/- 2%)

    T5631      -19.7%   (threshold: +/- 2%)

    T5642      -13.0%   (threshold: +/- 2%)

    T783       -2.7     (threshold: +/- 2%)

    T9020      -11.1    (threshold: +/- 2%)

    T9961      -3.4%    (threshold: +/- 2%)

    T1969 (compile_time/bytes_allocated)  -2.2%  (threshold: +/-1%)

    T1969 (compile_time/max_bytes_used)   +24.4% (threshold: +/-20%)

Additionally on other CIs:

    haddock.Cabal                  -10.0%   (threshold: +/- 5%)

    haddock.compiler               -9.5%    (threshold: +/- 5%)

    haddock.base (max bytes used)  +24.6%   (threshold: +/- 15%)

    T10370 (max bytes used, i386)  +18.4%   (threshold: +/- 15%)

Metric Decrease:

    T10421

    T10421a

    T12150

    T12227

    T12425

    T12545

    T12707

    T13035

    T14683

    T3064

    T4801

    T5030

    T5321FD

    T5321Fun

    T5631

    T5642

    T783

    T9020

    T9961

    haddock.Cabal

    haddock.compiler

Metric Decrease 'compile_time/bytes allocated':

    T1969

Metric Increase 'compile_time/max_bytes_used':

    T1969

    T10370

    haddock.base

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-14T15:50:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Drop --io-manager flag from testsuite configuration

This is no longer necessary as there are now dedicated testsuite ways

which run tests with WinIO.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-14T15:51:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">llvm-targets: Add i686 targets

Addresses #18422.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-18T15:38:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow unsaturated runRW# applications

Previously we had a very aggressive Core Lint check which caught

unsaturated applications of runRW#. However, there is nothing

wrong with such applications and they may naturally arise in desugared

Core. For instance, the desugared Core of Data.Primitive.Array.runArray#

from the `primitive` package contains:

    case ($) (runRW# @_ @_) (\s -> ...) of ...

In this case it's almost certain that ($) will be inlined, turning the

application into a saturated application. However, even if this weren't

the case there isn't a problem: CorePrep (after deleting an unnecessary

case) can simply generate code in its usual way, resulting in a call to

the Haskell definition of runRW#.

Fixes #18291.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-18T15:38:55-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Eli Schwartz</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">install: do not install sphinx doctrees

These files are 100% not needed at install time, and they contain

unreproducible info. See https://reproducible-builds.org/ for why this

matters.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/194b25ee97d93bc4bcb5bed9a0454debba7f2b6a">194b25ee</a></strong>

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Allow baseline commit to be set explicitly

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Use MR base commit as performance baseline

</pre>

</li>

<li>

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

<div>

<span>by Fendor</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Expose UnitInfoMap as it is part of the public API

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-18T22:11:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Only run llvm ways if llc is available

As noted in #18560, we previously would always run the LLVM ways since

`configure` would set `SettingsLlcCommand` to something non-null when

it otherwise couldn't find the `llc` executable. Now we rather probe for

the existence of the `llc` executable in the testsuite driver.

Fixes #18560.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-18T22:12:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: refactor GHC.CmmToAsm (#17957, #10143)

This patch removes the use of `sdocWithDynFlags` from GHC.CmmToAsm.*.Ppr

To do that I've had to make some refactoring:

* X86' and PPC's `Instr` are no longer `Outputable` as they require a

  `Platform` argument

* `Instruction` class now exposes `pprInstr :: Platform -> instr -> SDoc`

* as a consequence, I've refactored some modules to avoid .hs-boot files

* added (derived) functor instances for some datatypes parametric in the

  instruction type. It's useful for pretty-printing as we just have to

  map `pprInstr` before pretty-printing the container datatype.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/731c8d3bc5a84515793e5dadb26adf52f9280e13">731c8d3b</a></strong>

<div>

<span>by nineonine</span>

<i>at 2020-08-19T18:47:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -Wredundant-bang-patterns (#17340)

Add new flag '-Wredundant-bang-patterns' that enables checks for "dead" bangs.

Dead bangs are the ones that under no circumstances can force a thunk that

wasn't already forced. Dead bangs are a form of redundant bangs. The new check

is performed in Pattern-Match Coverage Checker along with other checks (namely,

redundant and inaccessible RHSs). Given

    f :: Bool -> Int

    f True = 1

    f !x   = 2

we can detect dead bang patterns by checking whether @x ~ ⊥@ is satisfiable

where the PmBang appears in 'checkGrdTree'. If not, then clearly the bang is

dead. Such a dead bang is then indicated in the annotated pattern-match tree by

a 'RedundantSrcBang' wrapping. In 'redundantAndInaccessibles', we collect

all dead bangs to warn about.

Note that we don't want to warn for a dead bang that appears on a redundant

clause. That is because in that case, we recommend to delete the clause wholly,

including its leading pattern match.

Dead bang patterns are redundant. But there are bang patterns which are

redundant that aren't dead, for example

    f !() = 0

the bang still forces the match variable, before we attempt to match on (). But

it is redundant with the forcing done by the () match. We currently don't

detect redundant bangs that aren't dead.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-08-19T18:48:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add right-to-left rule for pattern bindings

Fix #18323 by adding a few lines of code to handle non-recursive

pattern bindings.  see GHC.Tc.Gen.Bind

Note [Special case for non-recursive pattern bindings]

Alas, this confused the pattern-match overlap checker; see #18323.

Note that this patch only affects pattern bindings like that

for (x,y) in this program

  combine :: (forall a . [a] -> a) -> [forall a. a -> a]

          -> ((forall a . [a] -> a), [forall a. a -> a])

  breaks = let (x,y) = combine head ids

           in x y True

We need ImpredicativeTypes for those [forall a. a->a] types to be

valid. And with ImpredicativeTypes the old, unprincipled "allow

unification variables to unify with a polytype" story actually

works quite well. So this test compiles fine (if delicatedly) with

old GHCs; but not with QuickLook unless we add this patch

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/293c7fba6cde31151baaf2a92c723605ed458ade">293c7fba</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-21T09:36:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Put CFG weights into their own module (#17957)

It avoids having to query DynFlags to get them

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/50eb4460cd8412387e0c3755a9e0bafaced12bb2">50eb4460</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-21T09:36:38-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/659eb31b7a40f0aa2ba43c3454b5d9006fde837d">659eb31b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-21T09:36:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">NCG: Dwarf configuration

* remove references to DynFlags in GHC.CmmToAsm.Dwarf

* add specific Dwarf options in NCGConfig instead of directly querying

  the debug level

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-21T09:37:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix -ddump-stg flag

-ddump-stg was dumping the initial STG (just after Core-to-STG pass)

which was misleading because we want the final STG to know if a function

allocates or not. Now we have a new flag -ddump-stg-from-core for this and

-ddump-stg is deprecated.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-08-21T09:37:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Import qualified Prelude in Cmm/Parser.y

In preparation for the next version of 'happy', c95920 added a qualified

import to GHC/Parser.y but for some reason neglected GHC/Cmm/Parser.y

This patch adds the missing qualified import to GHC/Cmm/Parser.y and

also adds a clarifying comment to explain why this import is needed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/989c1c27b1ec69d8cf56b438f0173d92c3547ab5">989c1c27</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-21T11:27:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Test master branch as well

While these builds are strictly speaking redundant (since every commit

is tested by @marge-bot before making it into `master`), they are nevertheless

useful as they are displayed in the branch's commit list in GitLab's web interface.

Fixes #18595.</pre>

</li>

<li>

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

<div>

<span>by Aditya Gupta</span>

<i>at 2020-08-22T03:29:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">mkUnique refactoring (#18362)

Move uniqFromMask from Unique.Supply to Unique.

Move the the functions that call mkUnique from Unique to Builtin.Uniques

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/03cfcfd450335d5ecb63fec1f55d9feafabb2b4c">03cfcfd4</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-08-22T03:29:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add ubuntu 20.04 jobs for nightly and release

</pre>

</li>

<li>

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

<div>

<span>by Craig Ferguson</span>

<i>at 2020-08-22T03:30:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Utils: clarify docs slightly

The previous comment implies `nTimes n f` is either `f^{n+1}` or

`f^{2^n}` (when in fact it's `f^n`).

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-23T14:12:53+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do not print synonyms in :i (->), :i Type (#18594)

This adds a new printing flag `sdocPrintTypeAbbreviations` that is used

specifically to avoid ghci printing 'type (->) = (->)' and 'type Type = Type'.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-23T14:12:56+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move pprTyTcApp' inside pprTyTcApp

No semantic change

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/364258e0ad25bc95e69745554f5ca831ce80baf8">364258e0</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-24T00:32:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix types in silly shifts (#18589)

Patch written by Simon. I have only added a testcase.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-24T00:33:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Perf: make SDoc monad one-shot (#18202)

With validate-x86_64-linux-deb9-hadrian:

   T1969  -3.4% (threshold: +/-1%)

   T3294  -3.3% (threshold: +/-1%)

   T12707 -1.4% (threshold: +/-1%)

Additionally with validate-x86_64-linux-deb9-unreg-hadrian:

   T4801  -2.4% (threshold: +/-2%)

   T13035 -1.4% (threshold: +/-1%)

   T13379 -2.4% (threshold: +/-2%)

   ManyAlternatives -2.5% (threshold: +/-2%)

   ManyConstructors -3.0% (threshold: +/-2%)

Metric Decrease:

    T12707

    T1969

    T3294

    ManyAlternatives

    ManyConstructors

    T13035

    T13379

    T4801

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-24T10:04:20-04:00</i>

</div>

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

The bug was fixed by !3421.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/05550a5abc369e1cc4fc48def532ca9ba9adcad7">05550a5a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-24T10:04:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid roundtrip through SDoc

As found by @monoidal on https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3885#note_295126

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-25T07:37:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">SysTools.Process: Handle exceptions in readCreateProcessWithExitCode'

In #18069 we are observing MVar deadlocks from somewhere in ghc.exe.

This use of MVar stood out as being one of the more likely culprits.

Here we make sure that it is exception-safe.

</pre>

</li>

<li>

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

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-08-25T07:37:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use tcView, not coreView, in the pure unifier.

Addresses a lingering point within #11715.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-08-25T07:38:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use LIdP rather than (XRec p (IdP p))

This patch mainly just replaces use of

    XRec p (IdP p)

with

    LIdP p

One slightly more significant change is to parameterise

HsPatSynDetails over the pass rather than the argument type,

so that it's uniform with HsConDeclDetails and HsConPatDetails.

I also got rid of the dead code GHC.Hs.type.conDetailsArgs

But this is all just minor refactoring. No change in functionality.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8426a1364ba450fe48fc41a95b2ba76c8d1bb7c8">8426a136</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-25T07:38:54-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-26T04:50:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">linters: Make CPP linter skip image files

This patch adds an exclusion rule for `docs/users_guide/images`,

to avoid lint errors of PDF files.

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-26T04:50:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Color the logo on the front page of the PDF

This patch updates the logo with a recent color scheme.

This affects only the PDF version of the user's guide.

See also:

* https://mail.haskell.org/pipermail/ghc-devs/2020-August/019139.html

* https://gitlab.haskell.org/ghc/ghc/-/wikis/logo

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-26T04:50:58-04:00</i>

</div>

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

When we pretty-print a UnitId for the user, we try to map it back to its

origin package name, version and component to print

"package-version:component" instead of some hash.

The UnitId type doesn't carry these information, so we have to look into

a UnitState to find them. This is why the Outputable instance of

UnitId used `sdocWithDynFlags` in order to access the `unitState` field

of DynFlags.

This is wrong for several reasons:

1. The DynFlags are accessed when the message is printed, not when it is

   generated. So we could imagine that the unitState may have changed

   in-between. Especially if we want to allow unit unloading.

2. We want GHC to support several independent sessions at once, hence

   several UnitState. The current approach supposes there is a unique

   UnitState as a UnitId doesn't indicate which UnitState to use.

See the Note [Pretty-printing UnitId] in GHC.Unit for the new approach

implemented by this patch.

One step closer to remove `sdocDynFlags` field from `SDocContext`

(#10143).

Fix #18124.

Also fix some Backpack code to use SDoc instead of String.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-26T04:51:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: fix BigNat subtraction (#18604)

There was a confusion between the boolean expected by

withNewWordArrayTrimedMaybe and the boolean returned by subtracting

functions.

</pre>

</li>

<li>

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

<div>

<span>by Peter Trommler</span>

<i>at 2020-08-26T10:42:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PPC and X86: Portable printing of IEEE floats

GNU as and the AIX assembler support floating point literals.

SPARC seems to have support too but I cannot test on SPARC.

Curiously, `doubleToBytes` is also used in the LLVM backend.

To avoid endianness issues when cross-compiling float and double literals

are printed as C-style floating point values. The assembler then takes

care of memory layout and endianness.

This was brought up in #18431 by @hsyl20.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/770100e0266750a313b34a52a60968410fcf0769">770100e0</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-26T10:43:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops: Remove Monadic and Dyadic categories

There were four categories of primops: Monadic, Dyadic, Compare, GenPrimOp.

The compiler does not treat Monadic and Dyadic in any special way,

we can just replace them with GenPrimOp.

Compare is still used in isComparisonPrimOp.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/01ff8c89727a91cbc1571ae54f73f5919d6aaa71">01ff8c89</a></strong>

<div>

<span>by Aditya Gupta</span>

<i>at 2020-08-27T14:19:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Consolidate imports in getMinimalImports (#18264)

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-08-27T14:20:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make {hsExpr,hsType,pat}NeedsParens aware of boxed 1-tuples

`hsExprNeedsParens`, `hsTypeNeedsParens`, and `patNeedsParens`

previously assumed that all uses of explicit tuples in the source

syntax never need to be parenthesized. This is true save for one

exception: boxed one-tuples, which use the `Solo` data type from

`GHC.Tuple` instead of special tuple syntax. This patch adds the

necessary logic to the three `*NeedsParens` functions to handle

`Solo` correctly.

Fixes #18612.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-08-28T02:22:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add missing primop documentation (#18454)

- Add three pseudoops to primops.txt.pp, so that Haddock renders

  the documentation

- Update comments

- Remove special case for "->" - it's no longer exported from GHC.Prim

- Remove reference to Note [Compiling GHC.Prim] - the ad-hoc fix is no

  longer there after updates to levity polymorphism.

- Document GHC.Prim

- Remove the comment that lazy is levity-polymorphic.

  As far as I can tell, it never was: in 80e399639,

  only the unfolding was given an open type variable.

- Remove haddock hack in GHC.Magic - no longer neccessary after

  adding realWorld# to primops.txt.pp.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-08-28T02:23:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix use distro toolchian

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4517a38215eb72a4824c72d97377b9325059bf55">4517a382</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-08-28T02:23:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">document how build system find toolchains on Windows

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/329f7cb958551f5b384e2765a823770150152da2">329f7cb9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-31T22:59:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Better error message on invalid getSystemTimerManager call

Previously we would produce a rather unhelpful pattern match failure

error in the case where the user called `getSystemTimerManager` in a

program which isn't built with `-threaded`. This understandably confused

the user in #15616.

Fixes #15616.

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-08-31T22:59:50-04:00</i>

</div>

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

Avoid a similar regression in the future.

</pre>

</li>

<li>

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

<div>

<span>by Roland Senn</span>

<i>at 2020-08-31T23:00:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add additional tests for #18172 (Followup MR 3543)

There was still one active discussion [thread](https://gitlab.haskell.org/ghc/ghc/-/merge_requests/3543#note_284325) when MR !3543 got merged.

This MR adds the requested tests exercising the changes in

`compiler/GHC/HsToCore/Match/Literal.hs:warnAboutEmptyEnumerations` and its sub-functions.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-08-31T23:01:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Win32 and process submodules

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:01:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: fix slow-validate flavour (#18586)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85e13008fb9a319c0b79db7c626f37bf20731beb">85e13008</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-08-31T23:02:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update dominator code with fixes from the dom-lt package.

Two bugs turned out in the package that have been fixed since.

This MR includes this fixes in the GHC port of the code.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-08-31T23:02:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Dominators.hs: Use unix line endings

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6189cc04ca6c3d79126744e988b487f75ccef9e2">6189cc04</a></strong>

<div>

<span>by Moritz Angermann</span>

<i>at 2020-08-31T23:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[fixup 3433] move debugBelch into IF_DEBUG(linker)

The commit in dff1cb3d9c111808fec60190747272b973547c52 incorrectly left

the `debugBelch` function without a comment or IF_DEBUG(linker,)

decoration. This rectifies it.

Needs at least a 8.10 backport, as it was backported in 6471cc6aff80d5deebbdb1bf7b677b31ed2af3d5

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:03:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't store HomeUnit in UnitConfig

Allow the creation of a UnitConfig (hence of a UnitState) without having

a HomeUnit. It's required for #14335.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:04:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix documentation and fix "check" bignum backend (#18604)

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-08-31T23:04:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Set the dynamic-system-linker flag to Manual

This flag should be user controllable, hence Manual: True.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/380ef84587fb6890d100c338d1992a6994a4f02a">380ef845</a></strong>

<div>

<span>by Sven Tennie</span>

<i>at 2020-08-31T23:05:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Ignore more files

Ignore files from "new style" cabal builds (dist-newstyle folders) and

from clangd (C language server).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74a7fbff5a8f244cd44345bf987e26413bb1989e">74a7fbff</a></strong>

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-31T23:05:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Limit upper version of Happy for ghc-9.0 and earlier (#18620)

This patch adds the upper bound of a happy version for ghc-9.0

and earlier.

Currently, we can't use happy-1.20.0 for ghc-9.0.

See #18620.

</pre>

</li>

<li>

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

<div>

<span>by Takenobu Tani</span>

<i>at 2020-08-31T23:05:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Limit upper version of Happy for ghc-9.2 (#18620)

This patch adds the upper bound of a happy version for ghc-9.2.

Currently, We can use happy-1.19 or happy-1.20 for ghc-9.2.

See #18620.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-08-31T23:06:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add BigNat compat functions (#18613)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/884245dd29265b7bee12cda8c915da9c916251ce">884245dd</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-01T12:39:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix FastString lexicographic ordering (fix #18562)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-01T12:39:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove "Ord FastString" instance

FastStrings can be compared in 2 ways: by Unique or lexically. We don't

want to bless one particular way with an "Ord" instance because it leads

to bugs (#18562) or to suboptimal code (e.g. using lexical comparison

while a Unique comparison would suffice).

UTF-8 encoding has the advantage that sorting strings by their encoded

bytes also sorts them by their Unicode code points, without having to

decode the actual code points. BUT GHC uses Modified UTF-8 which

diverges from UTF-8 by encoding \0 as 0xC080 instead of 0x00 (to avoid

null bytes in the middle of a String so that the string can still be

null-terminated). This patch adds a new `utf8CompareShortByteString`

function that performs sorting by bytes but that also takes Modified

UTF-8 into account. It is much more performant than decoding the strings

into [Char] to perform comparisons (which we did in the previous patch).

Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-01T14:53:42-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-02T15:54:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Turn on -XMonoLocalBinds by default (#18430)

And fix the resulting type errors.

Co-authored-by: Krzysztof Gogolewski <krz.gogolewski@gmail.com>

Metric Decrease:

    parsing001

</pre>

</li>

<li>

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

<div>

<span>by David Feuer</span>

<i>at 2020-09-02T15:55:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove potential space leak from Data.List.transpose

Previously, `transpose` produced a list of heads

and a list of tails independently. This meant that

a function using only some heads, and only some tails,

could potentially leak space. Use `unzip` to work

around the problem by producing pairs and selector

thunks instead. Time and allocation behavior will

be worse, but there should be no more leak potential.</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-02T15:56:11-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/85e621234916e9b5d40174831a3b422bd99f8f83">85e62123</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-02T15:56:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add missing compat import/export functions

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/397c2b03e90e74c94ff55849adb6aa2a84e3e783">397c2b03</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-03T17:31:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Work around Raspbian's silly packaging decisions

See #17856.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4891c18a49876958b44e50dc6e2f24326d92052f">4891c18a</a></strong>

<div>

<span>by Kathryn Spiers</span>

<i>at 2020-09-03T17:32:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">expected-undocumented-flags remove kill flags

It looks like the flags were removed in https://gitlab.haskell.org/ghc/ghc/-/commit/3e27205a66b06a4501d87eb31e285eadbc693eb7

and can safely be removed here</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't rely on CLabel's Outputable instance in CmmToC

This is in preparation of the removal of sdocWithDynFlags (#10143),

hence of the refactoring of CLabel's Outputable instance.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/89ce7cdf977304cb7d0f325a013f822600c1bfbf">89ce7cdf</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: use Platform in foldRegs*

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/220ad8d67af345cf3decf82ff26c1e696d21ac93">220ad8d6</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T16:24:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: don't pass DynFlags to cmmImplementSwitchPlans

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-04T16:25:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce isBoxedTupleDataCon and use it to fix #18644

The code that converts promoted tuple data constructors to

`IfaceType`s in `GHC.CoreToIface` was using `isTupleDataCon`, which

conflates boxed and unboxed tuple data constructors. To avoid this,

this patch introduces `isBoxedTupleDataCon`, which is like

`isTupleDataCon` but only works for _boxed_ tuple data constructors.

While I was in town, I was horribly confused by the fact that there

were separate functions named `isUnboxedTupleCon` and

`isUnboxedTupleTyCon` (similarly, `isUnboxedSumCon` and

`isUnboxedSumTyCon`). It turns out that the former only works for

data constructors, despite its very general name! I opted to rename

`isUnboxedTupleCon` to `isUnboxedTupleDataCon` (similarly, I renamed

`isUnboxedSumCon` to `isUnboxedSumDataCon`) to avoid this potential

confusion, as well as to be more consistent with

the naming convention I used for `isBoxedTupleDataCon`.

Fixes #18644.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07bdcac38c90e79db9e4327f87c5400630dfe74b">07bdcac3</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-04T22:26:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Avoid hard-coded ld path on Windows

The fix to #17962 ended up regressing on Windows as it failed to

replicate the logic responsible for overriding the toolchain paths on

Windows. This resulted in a hard-coded path to a directory that likely

doesn't exist on the user's system (#18550).

</pre>

</li>

<li>

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

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-04T22:27:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Documented the as of yet undocumented '--print-*'  GHC flags,

as well as `-split-objs`, since that is related to

`--print-object-splitting-supported`.

See #18641

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-04T22:27:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move Hadrian's wiki pages in tree (fix #16165)

Only the debugging page contains interesting stuff. Some of this stuff

looks old (e.g. recommending "cabal install")...

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7980ae23696f2406c65ee498155b26c09d3d4394">7980ae23</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-05T14:50:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Consistently use stgMallocBytes instead of malloc

This can help in debugging RTS memory leaks since all allocations go

through the same interface.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">configure: Fix whitespace

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: More intelligent detection of locale availability

Previously ci.sh would unconditionally use C.UTF-8. However, this fails

on Centos 7, which appears not to provide this locale. Now we first try

C.UTF-8, then try en_US.UTF-8, then fail.

Works around #18607.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15dca84793d5ec4ff922726477923e40caa075eb">15dca847</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Rename RELEASE variable to RELEASE_JOB

This interfered with the autoconf variable of the same name, breaking

pre-release builds.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump Windows toolchain version

This should have been done when we bumped the bootstrap compiler to

8.8.4.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Drop Windows make job

These are a significant burden on our CI resources and end up failing

quite often due to #18274. Here I drop the make jobs during

validaion; it is now run only during the nightly builds.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/869f6e193d302c566ff0fbd530e8427440d0d2e3">869f6e19</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Drop Windows-specific output for parseTree

The normalise_slashes normaliser should handle this.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T5975[ab] as broken on Windows

Due to #7305.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/643785e3835de2de6c575e6418db0d4598b72a7d">643785e3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-05T14:51:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix typo

A small typo in a rule regular expression.

</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-07T09:33:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add clarification regarding poll/kqueue flags

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/10434d60c62fee7212f08bffde624702f81e93cf">10434d60</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-07T09:34:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Configure bignum backend in Hadrian builds

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-07T09:34:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Use hadrian builds for Windows release artifacts

</pre>

</li>

<li>

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

<div>

<span>by Moritz Angermann</span>

<i>at 2020-09-07T21:18:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[macOS] improved runpath handling

In b592bd98ff25730bbe3c13d6f62a427df8c78e28 we started using

-dead_strip_dylib on macOS when lining dynamic libraries and binaries.

The underlying reason being the Load Command Size Limit in macOS

Sierra (10.14) and later.

GHC will produce @rpath/libHS... dependency entries together with a

corresponding RPATH entry pointing to the location of the libHS...

library. Thus for every library we produce two Load Commands.  One to

specify the dependent library, and one with the path where to find it.

This makes relocating libraries and binaries easier, as we just need to

update the RPATH entry with the install_name_tool. The dynamic linker

will then subsitute each @rpath with the RPATH entries it finds in the

libraries load commands or the environement, when looking up @rpath

relative libraries.

-dead_strip_dylibs intructs the linker to drop unused libraries. This in

turn help us reduce the number of referenced libraries, and subsequently

the size of the load commands.  This however does not remove the RPATH

entries.  Subsequently we can end up (in extreme cases) with only a

single @rpath/libHS... entry, but 100s or more RPATH entries in the Load

Commands.

This patch rectifies this (slighly unorthodox) by passing *no* -rpath

arguments to the linker at link time, but -headerpad 8000.  The

headerpad argument is in hexadecimal and the maxium 32k of the load

command size.  This tells the linker to pad the load command section

enough for us to inject the RPATHs later.  We then proceed to link the

library or binary with -dead_strip_dylibs, and *after* the linking

inspect the library to find the left over (non-dead-stripped)

dependencies (using otool).  We find the corresponding RPATHs for each

@rpath relative dependency, and inject them into the library or binary

using the install_name_tool.  Thus achieving a deadstripped dylib (and

rpaths) build product.

We can not do this in GHC, without starting to reimplement a dynamic

linker as we do not know which symbols and subsequently libraries are

necessary.

Commissioned-by: Mercury Technologies, Inc. (mercury.com)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-07T21:19:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move DynFlags test into updateModDetailsIdInfos's caller (#17957)

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:42:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add stg_copyArray_barrier to RtsSymbols list

It's incredible that this wasn't noticed until now.

</pre>

</li>

<li>

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

<div>

<span>by Daishi Nakajima</span>

<i>at 2020-09-08T15:42:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Output performance test results in tabular format

this was suggested in #18417.

Change the print format of the values.

* Shorten commit hash

* Reduce precision of the "Value" field

* Shorten metrics name

  * e.g. runtime/bytes allocated -> run/alloc

* Shorten "MetricsChange"

  * e.g. unchanged -> unch, increased -> incr

And, print the baseline environment if there are baselines that were

measured in a different environment than the current environment.

If all "Baseline commit" are the same, print it once.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/44472daf500bf862921e89ad45c9741a07a64f61">44472daf</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-08T15:43:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the forall-or-nothing rule only apply to invisible foralls (#18660)

This fixes #18660 by changing `isLHsForAllTy` to

`isLHsInvisForAllTy`, which is sufficient to make the

`forall`-or-nothing rule only apply to invisible `forall`s. I also

updated some related documentation and Notes while I was in the

neighborhood.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:43:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Handle distributions without locales

Previously we would assume that the `locale` utility exists. However,

this is not so on Alpine as musl's locale support is essentially

non-existent.

(cherry picked from commit 17cdb7ac3b557a245fee1686e066f9f770ddc21e)

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-08T15:43:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Accept Centos 7 C.utf8 locale

Centos apparently has C.utf8 rather than C.UTF-8.

(cherry picked from commit d9f85dd25a26a04d3485470afb3395ee2dec6464)

</pre>

</li>

<li>

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

<div>

<span>by John Ericson</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use "to" instead of "2" in internal names of conversion ops

Change the constructors for the primop union, and also names of the

literal conversion functions.

"2" runs into trouble when we need to do conversions from fixed-width

types, and end up with thing like "Int642Word".

Only the names internal to GHC are changed, as I don't want to worry

about breaking changes ATM.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/822f10575d207a2a47b21ac853dcf28c655041c4">822f1057</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-09T00:46:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Postpone associated tyfam default checks until after typechecking

Previously, associated type family defaults were validity-checked

during typechecking. Unfortunately, the error messages that these

checks produce run the risk of printing knot-tied type constructors,

which will cause GHC to diverge. In order to preserve the current

error message's descriptiveness, this patch postpones these validity

checks until after typechecking, which are now located in the new

function `GHC.Tc.Validity.checkValidAssocTyFamDeflt`.

Fixes #18648.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add OptCoercionOpts

Use OptCoercionOpts to avoid threading DynFlags all the way down to

GHC.Core.Coercion.Opt

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add UnfoldingOpts and SimpleOpts

Milestone: after this patch, we only use 'unsafeGlobalDynFlags' for the

state hack and for debug in Outputable.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: add sm_pre_inline field into SimplMode (#17957)

It avoids passing and querying DynFlags down in the simplifier.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-09T11:19:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add comments about sm_dflags and simpleOptExpr

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7911d0d983a68eb0d54d7c1ba51326d6be737aae">7911d0d9</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-09-09T11:20:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove GENERATED pragma, as it is not being used

@alanz pointed out on ghc-devs that the payload of this pragma does

not appear to be used anywhere.

I (@bgamari) did some digging and traced the pragma's addition back to

d386e0d2 (way back in 2006!).

It appears that it was intended to be used by code generators for use

in informing the code coveraging checker about generated code

provenance. When it was added it used the pragma's "payload" fields as

source location information to build an "ExternalBox". However, it

looks like this was dropped a year later in 55a5d8d9.  At this point

it seems like the pragma serves no useful purpose.

Given that it also is not documented, I think we should remove it.

Updates haddock submodule

Closes #18639

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump Docker images

We now generate our Docker images via Dhall definitions, as described in

ghc/ci-images!52. Additionally, we are far more careful about where tools

come from, using the ALEX, HAPPY, HSCOLOR, and GHC environment variables

(set in the Dockerfiles) to find bootstrapping tools.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fix leakage of GHC in PATH into build

Previously hadrian would use GHC on PATH when configuring packages (or

fail if there is no such GHC). Fix this. Unfortunately this runs into

another bug in Cabal which we workaround.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/291a15dd8dfc03d493c0db36a9cb62fd4867db10">291a15dd</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-09T18:31:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">utils: Bump cabal-version of hp2ps and unlit

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4798caa0fefd7adf4c5b85fa84a6f28fcc6b350b">4798caa0</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-09T18:32:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts comment: RTS_TICKY_SYMBOLS moved from rts/Linker.c to rts/RtsSymbols.c

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/67ce72da1689058cb689ffbb6fcbd5cd12af56df">67ce72da</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T10:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add long-distance info for pattern bindings (#18572)

We didn't consider the RHS of a pattern-binding before, which led to

surprising warnings listed in #18572.

As can be seen from the regression test T18572, we get the expected

output now.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T10:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Big refactor using guard tree variants more closely following source syntax (#18565)

Previously, we desugared and coverage checked plain guard trees as

described in Lower Your Guards. That caused (in !3849) quite a bit of

pain when we need to partially recover tree structure of the input

syntax to return covered sets for long-distance information, for

example.

In this refactor, I introduced a guard tree variant for each relevant

source syntax component of a pattern-match (mainly match groups, match,

GRHS, empty case, pattern binding). I made sure to share as much

coverage checking code as possible, so that the syntax-specific checking

functions are just wrappers around the more substantial checking

functions for the LYG primitives (`checkSequence`, `checkGrds`).

The refactoring payed off in clearer code and elimination of all panics

related to assumed guard tree structure and thus fixes #18565.

I also took the liberty to rename and re-arrange the order of functions

and comments in the module, deleted some dead and irrelevant Notes,

wrote some new ones and gave an overview module haddock.

</pre>

</li>

<li>

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

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-10T10:36:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't include -fdiagnostics-color in argument hash

Otherwise the input hash will vary with whether colors are requested,

which changed with `isatty`.

Fixes #18672.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T17:02:00+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">.gitignore *.hiedb files

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/3777be14e104f040b826762f5ab42a8b898d85ae">3777be14</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-10T17:03:12+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Handle ⊥ and strict fields correctly (#18341)

In #18341, we discovered an incorrect digression from Lower Your Guards.

This MR changes what's necessary to support properly fixing #18341.

In particular, bottomness constraints are now properly tracked in the

oracle/inhabitation testing, as an additional field

`vi_bot :: Maybe Bool` in `VarInfo`. That in turn allows us to

model newtypes as advertised in the Appendix of LYG and fix #17725.

Proper handling of ⊥ also fixes #17977 (once again) and fixes #18670.

For some reason I couldn't follow, this also fixes #18273.

I also added a couple of regression tests that were missing. Most of

them were already fixed before.

In summary, this patch fixes #18341, #17725, #18273, #17977 and #18670.

Metric Decrease:

    T12227

</pre>

</li>

<li>

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

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Define TICKY_TICKY when compiling cmm RTS files.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15e67801ee72b94c6c826f641464c6be511685cc">15e67801</a></strong>

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos in TICKY_TICKY symbol names.

</pre>

</li>

<li>

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

<div>

<span>by David Himmelstrup</span>

<i>at 2020-09-11T09:59:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enable TICKY_TICKY for debug builds when building with makefiles.

</pre>

</li>

<li>

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

<div>

<span>by Sandy Maguire</span>

<i>at 2020-09-12T00:31:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add clamp function to Data.Ord

</pre>

</li>

<li>

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

<div>

<span>by Sandy Maguire</span>

<i>at 2020-09-12T00:31:37-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T00:32:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Disattach COMPLETE pragma lookup from TyCons

By not attaching COMPLETE pragmas with a particular TyCon and instead

assume that every COMPLETE pragma is applicable everywhere, we can

drastically simplify the logic that tries to initialise available

COMPLETE sets of a variable during the pattern-match checking process,

as well as fixing a few bugs.

Of course, we have to make sure not to report any of the

ill-typed/unrelated COMPLETE sets, which came up in a few regression

tests.

In doing so, we fix #17207, #18277 and #14422.

There was a metric decrease in #18478 by ~20%.

Metric Decrease:

    T18478

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/389a668343c0d4f5fa095112ff98d0da6998e99d">389a6683</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-12T00:32:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Pass input file to makeindex

Strangely I find that on Alpine (and apparently only on Alpine) the

latex makeindex command expects to be given a filename, lest it reads

from stdin.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/853d121acfcdae208e852edacac65a1b3e8cab83">853d121a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-12T00:33:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't quote argument to Hadrian's test-env flag (#18656)

Doing so causes the name of the test environment to gain an extra

set of double quotes, which changes the name entirely.

Fixes #18656.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8440b5fa1397940f2f293935927e690b34110a73">8440b5fa</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-12T00:33:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make sure we can read past perf notes

See #18656.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2157be52cd454353582b04d89492b239b90f91f7">2157be52</a></strong>

<div>

<span>by theobat</span>

<i>at 2020-09-12T21:27:04-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Avoid iterating twice in `zipTyEnv` (#18535)

zipToUFM is a new function to replace `listToUFM (zipEqual ks vs)`.

An explicit recursion is preferred due to the sensible nature of fusion.

    T12227 -6.0%

    T12545 -12.3%

    T5030  -9.0%

    T9872a -1.6%

    T9872b -1.6%

    T9872c -2.0%

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

Metric Decrease:

    T12227

    T12545

    T5030

    T9872a

    T9872b

    T9872c

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/69ea2fee35b4bcfd9253ee608f7135024186aeed">69ea2fee</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make `tcCheckSatisfiability` incremental (#18645)

By taking and returning an `InertSet`.

Every new `TcS` session can then pick up where a prior session left with

`setTcSInerts`.

Since we don't want to unflatten the Givens (and because it leads to

infinite loops, see !3971), we introduced a new variant of `runTcS`,

`runTcSInerts`, that takes and returns the `InertSet` and makes

sure not to unflatten the Givens after running the `TcS` action.

Fixes #18645 and #17836.

Metric Decrease:

    T17977

    T18478

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extract definition of DsM into GHC.HsToCore.Types

`DsM` was previously defined in `GHC.Tc.Types`, along with `TcM`. But

`GHC.Tc.Types` is in the set of transitive dependencies of `GHC.Parser`,

a set which we aim to minimise. Test case `CountParserDeps` checks for

that.

Having `DsM` in that set means the parser also depends on the innards of

the pattern-match checker in `GHC.HsToCore.PmCheck.Types`, which is the

reason we have that module in the first place.

In the previous commit, we represented the `TyState` by an `InertSet`,

but that pulls the constraint solver as well as 250 more modules into

the set of dependencies, triggering failure of `CountParserDeps`.

Clearly, we want to evolve the pattern-match checker (and the desugarer)

without being concerned by this test, so this patch includes a small

refactor that puts `DsM` into its own module.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-12T21:27:40-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hackily decouple the parser from the desugarer

In a hopefully temporary hack, I re-used the idea from !1957 of using a

nullary type family to break the dependency from GHC.Driver.Hooks on the

definition of DsM ("Abstract Data").

This in turn broke the last dependency from the parser to the desugarer.

More details in `Note [The Decoupling Abstract Data Hack]`.

In the future, we hope to undo this hack again in favour of breaking the

dependency from the parser to DynFlags altogether.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/35a7b7ecabeba39e53d6dea78ecc2d3eca8b1b24">35a7b7ec</a></strong>

<div>

<span>by Adam Sandberg Eriksson</span>

<i>at 2020-09-14T17:46:16-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: -B rts option sounds the bell on every GC (#18351)</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Populate gitlab cache after building

</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move ahead cabal cache restoration to before use of cabal

</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do the hadrian rebuild multicore

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07762eb5cfe735e131a7f017939a6b0ccfb28389">07762eb5</a></strong>

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-14T17:46:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Also cache other hadrian builds

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/8610bcbeb11b898f85f228b755fa8421b5ae3e34">8610bcbe</a></strong>

<div>

<span>by DenisFrezzato</span>

<i>at 2020-09-15T15:19:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix rtsopts documentation

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-15T15:19:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Care with implicit-parameter superclasses

Two bugs, #18627 and #18649, had the same cause: we were not

account for the fact that a constaint tuple might hide an implicit

parameter.

The solution is not hard: look for implicit parameters in

superclasses.  See Note [Local implicit parameters] in

GHC.Core.Predicate.

Then we use this new function in two places

* The "short-cut solver" in GHC.Tc.Solver.Interact.shortCutSolver

  which simply didn't handle implicit parameters properly at all.

  This fixes #18627

* The specialiser, which should not specialise on implicit parameters

  This fixes #18649

There are some lingering worries (see Note [Local implicit

parameters]) but things are much better.

</pre>

</li>

<li>

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

<div>

<span>by Zubin Duggal</span>

<i>at 2020-09-15T15:20:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export enrichHie from GHC.Iface.Ext.Ast

This is useful for `ghcide`

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-15T15:21:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Enhance metrics output

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4283feaa9e0826211f7a71d543054c989ea32965">4283feaa</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-15T15:21:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Introduce and use DerivClauseTys (#18662)

This switches `deriv_clause_tys` so that instead of using a list of

`LHsSigType`s to represent the types in a `deriving` clause, it now

uses a sum type. `DctSingle` represents a `deriving` clause with no

enclosing parentheses, while `DctMulti` represents a clause with

enclosing parentheses. This makes pretty-printing easier and avoids

confusion between `HsParTy` and the enclosing parentheses in

`deriving` clauses, which are different semantically.

Fixes #18662.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/90229c4b781184d0e59ac67afda90ed316f62bcd">90229c4b</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-16T04:53:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Include -f{write,validate}-ide-info in the User's Guide flag reference

Previously, these were omitted from the flag reference due to a

layout oversight in `docs/users_guide/flags.{rst,py}`.

Fixes #18426.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-16T04:53:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix erroneous usage of vsnprintf

As pointed out in #18685, this should be snprintf not vsnprintf. This

appears to be due to a cut-and-paste error.

Fixes #18658.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-16T04:54:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Rename ghci flag into internal-interpreter

"ghci" as a flag name was confusing because it really enables the

internal-interpreter. Even the ghci library had a "ghci" flag...

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-16T04:55:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make ghc-boot reexport modules from ghc-boot-th

Packages don't have to import both ghc-boot and ghc-boot-th. It makes

the dependency graph easier to understand and to refactor.

</pre>

</li>

<li>

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

<div>

<span>by Adam Sandberg Eriksson</span>

<i>at 2020-09-16T07:45:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">docs: correct haddock reference

[skip ci]</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-17T01:27:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Do absence analysis on stable unfoldings

Ticket #18638 showed that Very Bad Things happen if we fail

to do absence analysis on stable unfoldings.  It's all described

in Note [Absence analysis for stable unfoldings and RULES].

I'm a bit surprised this hasn't bitten us before. Fortunately

the fix is pretty simple.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/76d3bcbcef61ac71677855d6f90754ef019b9b4f">76d3bcbc</a></strong>

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T01:28:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replace deprecated git --recursive

The --recursive flag of git-clone has been replaced by the

--recurse-submodules flag since git 1.7.4, released in 2011.</pre>

</li>

<li>

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

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-17T01:28:38-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by HaskellMouse</span>

<i>at 2020-09-17T08:49:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Added explicit fixity to (~).

Solves #18252

</pre>

</li>

<li>

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

<div>

<span>by Cary Robbins</span>

<i>at 2020-09-17T08:50:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the 'IsString (Const a b)' instance polykinded on 'b'

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/win32: Fix missing #include's

These slipped through CI.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/76009ec84652f9b5c085f320ad9476e3693549f1">76009ec8</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Win32 submodule to 2.9.0.0

Also bumps Cabal, directory

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/147bb59826087300f989addfcf79e3956f6ed66b">147bb598</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-17T08:51:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump version to 9.0

Bumps haskeline and haddock submodules.

(cherry picked from commit f218cfc92f7b1a1e01190851972bb9a0e0f3c682)

</pre>

</li>

<li>

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

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T08:51:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make Z-encoding comment into a note

</pre>

</li>

<li>

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

<div>

<span>by Leif Metcalf</span>

<i>at 2020-09-17T08:51:43-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-17T08:52:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser.y: clarify treatment of @{-# UNPACK #-}

Before this patch, we had this parser production:

        ftype : ...

              | ftype PREFIX_AT tyarg  { ... }

And 'tyarg' is defined as follows:

        tyarg : atype              { ... }

              | unpackedness atype { ... }

So one might get the (false) impression that that parser production is

intended to parse things like:

        F @{-# UNPACK #-} X

However, the lexer wouldn't produce PREFIX_AT followed by 'unpackedness',

as the '@' operator followed by '{-' is not considered prefix.

Thus there's no point using 'tyarg' after PREFIX_AT,

and a simple 'atype' will suffice:

        ftype : ...

              | ftype PREFIX_AT atype  { ... }

This change has no user-facing consequences. It just makes the grammar a

bit more clear.

</pre>

</li>

<li>

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

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-17T08:52:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Documented '-m' flags for machine specific instruction extensions.

See #18641 'Documenting the Expected Undocumented Flags'

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

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

Some types need a Platform value to be pretty-printed: CLabel, Cmm

types, instructions, etc.

Before this patch they had an Outputable instance and the Platform value

was obtained via sdocWithDynFlags. It meant that the *renderer* of the

SDoc was responsible of passing the appropriate Platform value (e.g. via

the DynFlags given to showSDoc).  It put the burden of passing the

Platform value on the renderer while the generator of the SDoc knows the

Platform it is generating the SDoc for and there is no point passing a

different Platform at rendering time.

With this patch, we introduce a new OutputableP class:

   class OutputableP a where

      pdoc :: Platform -> a -> SDoc

With this class we still have some polymorphism as we have with `ppr`

(i.e. we can use `pdoc` on a variety of types instead of having a

dedicated `pprXXX` function for each XXX type).

One step closer removing `sdocWithDynFlags` (#10143) and supporting

several platforms (#14335).

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

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

Add a type parameter for the environment required by OutputableP. It

avoids tying Platform with OutputableP.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/37aa224ad5b1cfb17d472c7b88c5c76bf22a52f3">37aa224a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add note about OutputableP

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove pprPrec from Outputable (unused)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-17T20:04:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add clamping naturalToWord (fix #18697)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0799b3de3e3462224bddc0e4b6a3156d04a06361">0799b3de</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:55:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts/nonmoving: Add missing STM write barrier

When updating a TRec for a TVar already part of a transaction we

previously neglected to add the old value to the update remembered set.

I suspect this was the cause of #18587.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:56:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Refactor foreign export tracking

This avoids calling `libc` in the initializers which are responsible for

registering foreign exports. We believe this should avoid the corruption

observed in #18548.

See Note [Tracking foreign exports] in rts/ForeignExports.c for an

overview of the new scheme.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-18T15:56:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Refactor unloading of foreign export StablePtrs

Previously we would allocate a linked list cell for each foreign export.

Now we can avoid this by taking advantage of the fact that they are

already broken into groups.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/45fa82182bc61e3966fd51496c35130cd067a5df">45fa8218</a></strong>

<div>

<span>by Simon Jakobi</span>

<i>at 2020-09-19T06:57:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Deprecate Data.Semigroup.Option

Libraries email: https://mail.haskell.org/pipermail/libraries/2018-April/028724.html

GHC issue: https://gitlab.haskell.org/ghc/ghc/issues/15028

Corresponding PRs for deepseq:

* https://github.com/haskell/deepseq/pull/55

* https://github.com/haskell/deepseq/pull/57

Bumps the deepseq submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2229d570fc78867190febb4f13c799b258a41f6d">2229d570</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Require happy >=1.20

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci.sh: Enforce minimum happy/alex versions

Also, always invoke cabal-install to ensure that happy/alex symlinks are

up-to-date.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:47:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Ensure that cabal-install overwrites existing executables

Previously cabal-install wouldn't overwrite toolchain executables if

they already existed (as they likely would due to caching).

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-19T15:48:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Wire in constraint tuples

This wires in the definitions of the constraint tuple classes. The

key changes are in:

* `GHC.Builtin.Types`, where the `mk_ctuple` function is used to

  define constraint tuple type constructors, data constructors, and

  superclass selector functions, and

* `GHC.Builtin.Uniques`. In addition to wiring in the `Unique`s for

  constraint tuple type and data constructors, we now must wire in

  the superclass selector functions. Luckily, this proves to be not

  that challenging. See the newly added comments.

Historical note: constraint tuples used to be wired-in until about

five years ago, when commit 130e93aab220bdf14d08028771f83df210da340b

turned them into known-key names. This was done as part of a larger

refactor to reduce the number of special cases for constraint tuples,

but the commit message notes that the main reason that constraint

tuples were made known-key (as opposed to boxed/unboxed tuples, which

are wired in) is because it was awkward to wire in the superclass

selectors. This commit solves the problem of wiring in superclass

selectors.

Fixes #18635.

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

Metric Decrease:

    T10421

    T12150

    T12227

    T12234

    T12425

    T13056

    T13253-spj

    T18282

    T18304

    T5321FD

    T5321Fun

    T5837

    T9961

Metric Decrease (test_env='x86_64-linux-deb9-unreg-hadrian'):

    T12707

Metric Decrease (test_env='x86_64-darwin'):

    T4029

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

</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-09-19T15:48:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Export singleton function from Data.List

Data.OldList exports a monomorphized singleton function but

it is not re-exported by Data.List. Adding the export to

Data.List causes a conflict with a 14-year old function of the

same name and type by SPJ in GHC.Utils.Misc. We can't just remove

this function because that leads to a problems when building

GHC with a stage0 compiler that does not have singleton in

Data.List yet. We also can't hide the function in GHC.Utils.Misc

since it is not possible to hide a function from a module if the

module does not export the function. To work around this, all

places where the Utils.Misc singleton was used now use a qualified

version like Utils.singleton and in GHC.Utils.Misc we are very

specific about which version we export.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-19T15:49:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Stack resolver

</pre>

</li>

<li>

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

<div>

<span>by John Ericson</span>

<i>at 2020-09-19T15:49:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cinch -fno-warn-name-shadowing down to specific GHCi module

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-19T15:49:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add quick-validate Hadrian flavour (quick + -Werror)

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-19T15:50:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix docs who misstated how the RTS treats size suffixes.

They are parsed as multiples of 1024. Not 1000. The docs

used to imply otherwise.

See decodeSize in rts/RtsFlags.c for the logic for this.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-19T15:50:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a codeblock in ghci.rst

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:51:07-04:00</i>

</div>

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/885ecd18e084e4e2b15fbc5de0aa5222f2573387">885ecd18</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:51:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Fail on Sphinx syntax errors

Specifically the "Inline literal start-string without end-string"

warning, which typically means that the user neglected to separate

an inline code block from suffix text with a backslash.

</pre>

</li>

<li>

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

<div>

<span>by David Feuer</span>

<i>at 2020-09-19T15:51:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Unpack the MVar in Compact

The `MVar` lock in `Compact` was unnecessarily lazy, creating an extra indirection and wasting two words. Make it strict.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/760307cf5511d970dfddf7fa4b502b4e3394b197">760307cf</a></strong>

<div>

<span>by Artyom Kuznetsov</span>

<i>at 2020-09-19T15:52:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove GADT self-reference check (#11554, #12081, #12174, fixes #15942)

Reverts 430f5c84dac1eab550110d543831a70516b5cac8

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/057db94ce038970b14df1599fe83097c284b9c1f">057db94c</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-19T15:52:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Drop field initializer on thread_basic_info_data_t

This struct has a number of fields and we only care that the value is

initialized with zeros. This eliminates the warnings noted in #17905.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/87e2e2b17afed82d30841d5b44c977123b93ecc4">87e2e2b1</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-19T23:55:30+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Resolve shift/reduce conflicts with %shift (#17232)

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Unmark T12971 as broken on Windows

It's unclear why, but this no longer seems to fail.

Closes #17945.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/816811d45897afec3543ade30c63dcddf56828a8">816811d4</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Unmark T5975[ab] as broken on Windows

Sadly it's unclear *why* they have suddenly started working.

Closes #7305.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/43a43d396e30931c1fa68b054ae032d2bd1daa98">43a43d39</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base/testsuite: Add missing LANGUAGE pragma in ThreadDelay001

Only affected the Windows codepath.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Update expected output for outofmem on Windows

The error originates from osCommitMemory rather than getMBlocks.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark some GHCi/Makefile tests as broken on Windows

See #18718.

</pre>

</li>

<li>

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

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Fix WinIO error message normalization

This wasn't being applied to stderr.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/93ab3e8d235610b2cb339a5bad9ad2848eab18d4">93ab3e8d</a></strong>

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark tempfiles as broken on Win32 without WinIO

The old POSIX emulation appears to ignore the user-requested prefix.

</pre>

</li>

<li>

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

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-09-20T20:30:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark TH_spliceE5_prof as broken on Windows

Due to #18721.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-21T16:45:47-04:00</i>

</div>

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

Fixes #18715.

</pre>

</li>

<li>

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

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-21T16:45:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disallow constraints in KindSigCtxt

This patch cleans up how `GHC.Tc.Validity` classifies `UserTypeCtxt`s

that can only refer to kind-level positions, which is important for

rejecting certain classes of programs. In particular, this patch:

* Introduces a new `TypeOrKindCtxt` data type and

  `typeOrKindCtxt :: UserTypeCtxt -> TypeOrKindCtxt` function, which

  determines whether a `UserTypeCtxt` can refer to type-level

  contexts, kind-level contexts, or both.

* Defines the existing `allConstraintsAllowed` and `vdqAllowed`

  functions in terms of `typeOrKindCtxt`, which avoids code

  duplication and ensures that they stay in sync in the future.

The net effect of this patch is that it fixes #18714, in which it was

discovered that `allConstraintsAllowed` incorrectly returned `True`

for `KindSigCtxt`. Because `typeOrKindCtxt` now correctly classifies

`KindSigCtxt` as a kind-level context, this bug no longer occurs.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-21T16:46:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Add extra-deps: happy-1.20 to stack.yaml

GHC now requires happy-1.20, which isn't available in LTS-16.14.

Fixes #18726.</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-22T05:37:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Better eta-expansion (again) and don't specilise DFuns

This patch fixes #18223, which made GHC generate an exponential

amount of code.  There are three quite separate changes in here

1.  Re-engineer eta-expansion (again).  The eta-expander was

    generating lots of intermediate stuff, which could be optimised

    away, but which choked the simplifier meanwhile.  Relatively

    easy to kill it off at source.

    See Note [The EtaInfo mechanism] in GHC.Core.Opt.Arity.

    The main new thing is the use of pushCoArg in getArg_maybe.

2.  Stop Specialise specalising DFuns.  This is the cause of a huge

    (and utterly unnecessary) blowup in program size in #18223.

    See Note [Do not specialise DFuns] in GHC.Core.Opt.Specialise.

    I also refactored the Specialise monad a bit... it was silly,

    because it passed on unchanging values as if they were mutable

    state.

3.  Do an extra Simplifer run, after SpecConstra and before

    late-Specialise.  I found (investigating perf/compiler/T16473)

    that failing to do this was crippling *both* SpecConstr *and*

    Specialise.  See Note [Simplify after SpecConstr] in

    GHC.Core.Opt.Pipeline.

    This change does mean an extra run of the Simplifier, but only

    with -O2, and I think that's acceptable.

    T16473 allocates *three* times less with this change.  (I changed

    it to check runtime rather than compile time.)

Some smaller consequences

* I moved pushCoercion, pushCoArg and friends from SimpleOpt

  to Arity, because it was needed by the new etaInfoApp.

  And pushCoValArg now returns a MCoercion rather than Coercion for

  the argument Coercion.

* A minor, incidental improvement to Core pretty-printing

This does fix #18223, (which was otherwise uncompilable. Hooray.  But

there is still a big intermediate because there are some very deeply

nested types in that program.

Modest reductions in compile-time allocation on a couple of benchmarks

    T12425     -2.0%

    T13253    -10.3%

Metric increase with -O2, due to extra simplifier run

    T9233     +5.8%

    T12227    +1.8%

    T15630    +5.0%

There is a spurious apparent increase on heap residency on T9630,

on some architectures at least.  I tried it with -G1 and the residency

is essentially unchanged.

Metric Increase

    T9233

    T12227

    T9630

Metric Decrease

    T12425

    T13253

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/416bd50e58b23ad70813b18a913ca77a3ab6e936">416bd50e</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-22T05:37:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix the occurrence analyser

Ticket #18603 demonstrated that the occurrence analyser's

handling of

  local RULES for imported Ids

(which I now call IMP-RULES) was inadequate.  It led the simplifier

into an infnite loop by failing to label a binder as a loop breaker.

The main change in this commit is to treat IMP-RULES in a simple and

uniform way: as extra rules for the local binder.  See

  Note [IMP-RULES: local rules for imported functions]

This led to quite a bit of refactoring.  The result is still tricky,

but it's much better than before, and better documented I think.

Oh, and it fixes the bug.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-22T05:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck - Comments only: Replace /~ by ≁

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-22T05:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Rewrite inhabitation test

We used to produce inhabitants of a pattern-match refinement type Nabla

in the checker in at least two different and mostly redundant ways:

  1. There was `provideEvidence` (now called

     `generateInhabitingPatterns`) which is used by

     `GHC.HsToCore.PmCheck` to produce non-exhaustive patterns, which

     produces inhabitants of a Nabla as a sub-refinement type where all

     match variables are instantiated.

  2. There also was `ensure{,All}Inhabited` (now called

     `inhabitationTest`) which worked slightly different, but was

     whenever new type constraints or negative term constraints were

     added. See below why `provideEvidence` and `ensureAllInhabited`

     can't be the same function, the main reason being performance.

  3. And last but not least there was the `nonVoid` test, which tested

     that a given type was inhabited. We did use this for strict fields

     and -XEmptyCase in the past.

The overlap of (3) with (2) was always a major pet peeve of mine. The

latter was quite efficient and proven to work for recursive data types,

etc, but could not handle negative constraints well (e.g. we often want

to know if a *refined* type is empty, such as `{ x:[a] | x /= [] }`).

Lower Your Guards suggested that we could get by with just one, by

replacing both functions with `inhabitationTest` in this patch.

That was only possible by implementing the structure of φ constraints

as in the paper, namely the semantics of φ constructor constraints.

This has a number of benefits:

  a. Proper handling of unlifted types and strict fields, fixing #18249,

     without any code duplication between

     `GHC.HsToCore.PmCheck.Oracle.instCon` (was `mkOneConFull`) and

     `GHC.HsToCore.PmCheck.checkGrd`.

  b. `instCon` can perform the `nonVoid` test (3) simply by emitting

     unliftedness constraints for strict fields.

  c. `nonVoid` (3) is thus simply expressed by a call to

     `inhabitationTest`.

  d. Similarly, `ensureAllInhabited` (2), which we called after adding

     type info, now can similarly be expressed as the fuel-based

     `inhabitationTest`.

See the new `Note [Why inhabitationTest doesn't call generateInhabitingPatterns]`

why we still have tests (1) and (2).

Fixes #18249 and brings nice metric decreases for `T17836` (-76%) and

`T17836b` (-46%), as well as `T18478` (-8%) at the cost of a few very

minor regressions (< +2%), potentially due to the fact that

`generateInhabitingPatterns` does more work to suggest the minimal

COMPLETE set.

Metric Decrease:

    T17836

    T17836b

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/086ef01813069fad84cafe81cab37527d41c8568">086ef018</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-23T06:52:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove the list of loaded modules from the ghci prompt

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-23T06:52:44-04:00</i>

</div>

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

* Bump bytestring to 0.10.12.0

* Bump Cabal to 3.4.0.0-rc3

* Bump Win32 to 2.10.0.0

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/667d63558a694e12974ace723b553950f6080365">667d6355</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

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

* Don't depend on the selected backend to know if we print Asm or C

  labels: we already have PprStyle to determine this. Moreover even when

  a native backend is used (NCG, LLVM) we may want to C headers

  containing pretty-printed labels, so it wasn't a good predicate

  anyway.

* Make pretty-printing code clearer and avoid partiality

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-23T20:43:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Preliminary work towards removing DynFlags -> Driver.Ppr dependency

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/31fea307499009977fdf3dadedc98cfef986077a">31fea307</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-23T20:44:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove redundant "do", "return" and language extensions from base

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/04d6433158d95658684cf419c4ba5725d2aa539e">04d64331</a></strong>

<div>

<span>by syd@cs-syd.eu</span>

<i>at 2020-09-24T13:15:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update Lock.hs with more documentation to make sure that the Boolean return value is clear.

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/97cff9190d346c3b51c32c88fd145fcf1e6678f1">97cff919</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-24T13:16:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement Quick Look impredicativity

This patch implements Quick Look impredicativity (#18126), sticking

very closely to the design in

    A quick look at impredicativity, Serrano et al, ICFP 2020

The main change is that a big chunk of GHC.Tc.Gen.Expr has been

extracted to two new modules

    GHC.Tc.Gen.App

    GHC.Tc.Gen.Head

which deal with typechecking n-ary applications, and the head of

such applications, respectively.  Both contain a good deal of

documentation.

Three other loosely-related changes are in this patch:

* I implemented (partly by accident) points (2,3)) of the accepted GHC

  proposal "Clean up printing of foralls", namely

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

        master/proposals/0179-printing-foralls.rst

  (see #16320).

  In particular, see Note [TcRnExprMode] in GHC.Tc.Module

  - :type instantiates /inferred/, but not /specified/, quantifiers

  - :type +d instantiates /all/ quantifiers

  - :type +v is killed off

  That completes the implementation of the proposal,

  since point (1) was done in

    commit df08468113ab46832b7ac0a7311b608d1b418c4d

    Author: Krzysztof Gogolewski <krzysztof.gogolewski@tweag.io>

    Date:   Mon Feb 3 21:17:11 2020 +0100

    Always display inferred variables using braces

* HsRecFld (which the renamer introduces for record field selectors),

  is now preserved by the typechecker, rather than being rewritten

  back to HsVar.  This is more uniform, and turned out to be more

  convenient in the new scheme of things.

* The GHCi debugger uses a non-standard unification that allows the

  unification variables to unify with polytypes.  We used to hack

  this by using ImpredicativeTypes, but that doesn't work anymore

  so I introduces RuntimeUnkTv.  See Note [RuntimeUnkTv] in

  GHC.Runtime.Heap.Inspect

Updates haddock submodule.

WARNING: this patch won't validate on its own.  It was too

hard to fully disentangle it from the following patch, on

type errors and kind generalisation.

Changes to tests

* Fixes #9730 (test added)

* Fixes #7026 (test added)

* Fixes most of #8808, except function `g2'` which uses a

  section (which doesn't play with QL yet -- see #18126)

  Test added

* Fixes #1330. NB Church1.hs subsumes Church2.hs, which is now deleted

* Fixes #17332 (test added)

* Fixes #4295

* This patch makes typecheck/should_run/T7861 fail.

  But that turns out to be a pre-existing bug: #18467.

  So I have just made T7861 into expect_broken(18467)

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-09-24T13:16:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve kind generalisation, error messages

This patch does two things:

* It refactors GHC.Tc.Errors a bit.  In debugging Quick Look I was

  forced to look in detail at error messages, and ended up doing a bit

  of refactoring, esp in mkTyVarEqErr'.  It's still quite a mess, but

  a bit better, I think.

* It makes a significant improvement to the kind checking of type and

  class declarations. Specifically, we now ensure that if kind

  checking fails with an unsolved constraint, all the skolems are in

  scope.  That wasn't the case before, which led to some obscure error

  messages; and occasional failures with "no skolem info" (eg #16245).

Both of these, and the main Quick Look patch itself, affect a /lot/ of

error messages, as you can see from the number of files changed.  I've

checked them all; I think they are as good or better than before.

Smaller things

* I documented the various instances of VarBndr better.

  See Note [The VarBndr tyep and its uses] in GHC.Types.Var

* Renamed GHC.Tc.Solver.simpl_top to simplifyTopWanteds

* A bit of refactoring in bindExplicitTKTele, to avoid the

  footwork with Either.  Simpler now.

* Move promoteTyVar from GHC.Tc.Solver to GHC.Tc.Utils.TcMType

Fixes #16245 (comment 211369), memorialised as

  typecheck/polykinds/T16245a

Also fixes the three bugs in #18640

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-24T13:17:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Desugar string literal patterns with -XRebindableSyntax correctly (#18708)

Fixes #18708.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/007940d2fa1ac4f8046989d4af1d088914612a78">007940d2</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-09-24T13:17:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Namespace the Hadrian linting rule for base

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-09-25T21:10:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make sizeExpr strict in the size threshold to facilitate WW.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:10:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci.sh: Factor out common utilities

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:10:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ci: Add ad-hoc performance testing rule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/29885f076219d878d2c976e78b7960a1a5938a96">29885f07</a></strong>

<div>

<span>by Zubin Duggal</span>

<i>at 2020-09-25T21:11:32-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Stop removing definitions of record fields in GHC.Iface.Ext.Ast

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-25T21:12:08-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Drop Darwin cleanup job

We now have a proper periodic clean-up script installed on the runners.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/277d20af1ce54c7e2c76dfe3b96c54babceeea41">277d20af</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

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

They have been fixed by !3959, I believe.

Fixes #18371.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

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

The egregious performance hits are gone since !4050.

So we fix #18609.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-25T21:12:44-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Accept new test output for #17218

The expected test output was plain wrong.

It has been fixed for a long time.

Thus we can close #17218.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/516062366ed1957e499f27dfc6b685a073a18400">51606236</a></strong>

<div>

<span>by Sven Tennie</span>

<i>at 2020-09-25T21:13:19-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Print RET_BIG stack closures

A RET_BIG closure has a large bitmap that describes it's payload and can

be printed with printLargeBitmap().

Additionally, the output for payload closures of small and big bitmaps is

changed: printObj() is used to print a bit more information about what's

on the stack.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2707c4eae4cf99e6da2709e128f560d91e468357">2707c4ea</a></strong>

<div>

<span>by Arnaud Spiwack</span>

<i>at 2020-09-25T21:13:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pattern guards BindStmt always use multiplicity Many

Fixes #18439 .

The rhs of the pattern guard was consumed with multiplicity one, while

the pattern assumed it was Many. We use Many everywhere instead.

This is behaviour consistent with that of `case` expression. See #18738.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/92daad241bf136a10346ecbf520d62921c82bf7d">92daad24</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-25T21:14:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: refactor backend modules

* move backends into GHC.Num.Backend.*

* split backend selection into GHC.Num.Backend and

  GHC.Num.Backend.Selected to avoid duplication with the Check backend

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/04bc50b3c8e40387a0d0f090ea23cd68923f1834">04bc50b3</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-25T21:14:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement extended GCD (#18427)

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-25T21:15:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typed holes causing linearity errors (#18491)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/83407ffc7acc00cc025b9f6ed063add9ab9f9bcc">83407ffc</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-25T21:15:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Various documentation fixes

* Remove UnliftedFFITypes from conf. Some time ago, this extension

  was undocumented and we had to silence a warning.

  This is no longer needed.

* Use r'' in conf.py. This fixes a Sphinx warning:

  WARNING: Support for evaluating Python 2 syntax is deprecated and will be removed in Sphinx 4.0. Convert docs/users_guide/conf.py to Python 3 syntax.

* Mark GHCForeignImportPrim as documented

* Fix formatting in template_haskell.rst

* Remove 'recursive do' from the list of unsupported items in TH

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-26T05:36:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Big refactor of module structure

  * Move everything from `GHC.HsToCore.PmCheck.*` to

    `GHC.HsToCore.Pmc.*` in analogy to `GHC.Tc`, rename exported

    `covCheck*` functions to `pmc*`

  * Rename `Pmc.Oracle` to `Pmc.Solver`

  * Split off the LYG desugaring and checking steps into their own

    modules (`Pmc.Desugar` and `Pmc.Check` respectively)

  * Split off a `Pmc.Utils` module with stuff shared by

    `Pmc.{,Desugar,Check,Solver}`

  * Move `Pmc.Types` to `Pmc.Solver.Types`, add a new `Pmc.Types` module

    with all the LYG types, which form the interfaces between

    `Pmc.{Desugar,Check,Solver,}`.

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-26T05:36:46-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extract SharedIdEnv into its own module

It's now named `GHC.Types.Unique.SDFM.UniqSDFM`.

The implementation is more clear about its stated goals and supported

operations.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-26T05:37:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add bigNatFromWordArray

Reimplementation of integer-gmp's byteArrayToBigNat#

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make 'undefined x' linear in 'x' (#18731)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/160fba4aa306c0649c72a6dcd7c98d9782a0e74b">160fba4a</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-26T13:19:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Disallow linear types in FFI (#18472)

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-26T13:19:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix handling of function coercions (#18747)

This was broken when we added multiplicity to the function type.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T03:01:31+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Comments: change outdated reference to mergeOps

As of 686e06c59c3aa6b66895e8a501c7afb019b09e36,

GHC.Parser.PostProcess.mergeOps no longer exists.

[ci skip]

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T10:04:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't rearrange (->) in the renamer

The parser produces an AST where the (->)

is already associated correctly:

  1. (->) has the least possible precedence

  2. (->) is right-associative

Thus we don't need to handle it in mkHsOpTyRn.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-27T10:04:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove outdated comment in rnHsTyKi

This comment dates back to 3df40b7b78044206bbcffe3e2c0a57d901baf5e8

and does not seem relevant anymore.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/583a2070f1ad9162a365b034b27c3b80daafb8df">583a2070</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-29T00:31:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Optimize NthCo (FunCo ...) in coercion opt

We were missing this case previously.

Close #18528.

Metric Decrease:

    T18223

    T5321Fun

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix kind inference when checking datacons

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5830a12c46e7227c276a8a71213057595ee4fc04">5830a12c</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">New linear types syntax: a %p -> b (#18459)

Implements GHC Proposal #356

Updates the haddock submodule.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-09-29T00:32:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Improve error messages for (a %m) without LinearTypes

Detect when the user forgets to enable the LinearTypes

extension and produce a better error message.

Steals the (a %m) syntax from TypeOperators, the workaround

is to write (a % m) instead.

</pre>

</li>

<li>

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

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-29T00:32:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Description of flag `-H` was in 'verbosity options', moved to 'misc'.

Fixes #18699

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74c797f6b72c4d01f5e0092dfac1461f3f3dd7a2">74c797f6</a></strong>

<div>

<span>by Benjamin Maurer</span>

<i>at 2020-09-29T00:33:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Workaround for #18623: GHC crashes bc. under rlimit for vmem it will reserve

_all_ of it, leaving nothing for, e.g., thread stacks.

Fix will only allocate 2/3rds and check whether remainder is at least large

enough for minimum amount of thread stacks.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4365d77a0b306ada61654c3648b844cfa0f4fdcf">4365d77a</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-09-29T00:33:57-04:00</i>

</div>

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

ghc/ghc!3220 ended up fixing #18501. This patch adds a regression

test for #18501 to ensure that it stays fixed.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-29T17:24:03+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make the parser module less dependent on DynFlags

Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-30T02:48:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">PmCheck: Long-distance information for LocalBinds (#18626)

Now `desugarLocalBind` (formerly `desugarLet`) reasons about

  * `FunBind`s that

    * Have no pattern matches (so which aren't functions)

    * Have a singleton match group with a single GRHS

    * (which may have guards)

  * and looks through trivial post-typechecking `AbsBinds` in doing so

    to pick up the introduced renamings.

And desugars to `PmLet` LYG-style guards. Since GRHSs are no longer

denoted simply by `NonEmpty PmGRHS`, but also need to carry a `[PmGrd]`

for the `PmLet`s from `LocalBind`s, I added `PmGRHSs` to capture that.

Since we call out to the desugarer more often, I found that there were

superfluous warnings emitted when desugaring e.g. case expressions.

Thus, I made sure that we deactivate any warnings in the LYG desugaring

steps by the new wrapper function `noCheckDs`.

There's a regression test in `T18626`. Fixes #18626.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T02:49:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T12971 as broken on Windows

Due to #17945.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/6527fc57b8e099703f5bdb5ec7f1dfd421651972">6527fc57</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T02:49:03-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump Cabal, hsc2hs, directory, process submodules

Necessary for recent Win32 bump.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-30T02:49:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unsafeGlobalDynFlags (#17957, #14597)

There are still global variables but only 3 booleans instead of a single

DynFlags.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-09-30T02:49:41-04:00</i>

</div>

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

Some removed globals variables were still declared in the RTS.

They were removed in the following commits:

* 4fc6524a2a4a0003495a96c8b84783286f65c198

* 0dc7985663efa1739aafb480759e2e2e7fca2a36

* bbd3c399939311ec3e308721ab87ca6b9443f358

</pre>

</li>

<li>

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

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-30T02:50:17-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Omit redundant kind equality check in solver

See updated Note [Use loose types in inert set] in

GHC.Tc.Solver.Monad.

Close #18753.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/395498260ab444f5e1ec82d716bea3cc3ad887f7">39549826</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-09-30T02:50:54-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Pmc: Don't call exprType on type arguments (#18767)

Fixes #18767.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/235e410f63a4725bbc4466dbdef7d5f661793e84">235e410f</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-09-30T02:51:29-04:00</i>

</div>

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

Close #10709

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-09-30T22:31:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian/doc: Clarify documentation of key-value configuration</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:34:53-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:34:53-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Allow fusion with catMaybes (#18574)

Metric Decrease:

   T18574

</pre>

</li>

<li>

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

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add mainModuleNameIs and demote mainModIs

Add `mainModuleNameIs` to DynFlags and demote

`mainModIs` to function which uses the homeUnit from DynFlags

it is created from.

</pre>

</li>

<li>

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

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use HomeUnit for main module without module declaration

</pre>

</li>

<li>

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

<div>

<span>by Fendor</span>

<i>at 2020-10-01T18:35:33-04:00</i>

</div>

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

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use ADTs for parser errors/warnings

Haskell and Cmm parsers/lexers now report errors and warnings using ADTs

defined in GHC.Parser.Errors. They can be printed using functions in

GHC.Parser.Errors.Ppr.

Some of the errors provide hints with a separate ADT (e.g. to suggest to

turn on some extension). For now, however, hints are not consistent

across all messages. For example some errors contain the hints in the

main message. I didn't want to change any message with this patch. I

expect these changes to be discussed and implemented later.

Surprisingly, this patch enhances performance. On CI

(x86_64/deb9/hadrian, ghc/alloc):

   parsing001         -11.5%

   T13719             -2.7%

   MultiLayerModules  -3.5%

   Naperian           -3.1%

Bump haddock submodule

Metric Decrease:

    MultiLayerModules

    Naperian

    T13719

    parsing001

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Less DynFlags in Header parsing

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser: remove some unused imports

These are not reported by GHC because Happy adds {-# OPTIONS_GHC -w #-}

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/93d5de165a81dfb335bf1646c2e29956f5ab55ea">93d5de16</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:36:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't import GHC.Unit to reduce the number of dependencies

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-01T18:36:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't attach CPR signatures to NOINLINE data structures (#18154)

Because the generated `KindRep`s don't have an unfolding, !3230 did not

actually stop to compute, attach and serialise unnecessary CPR

signatures for them. As already said in

`Note [CPR for data structures]`, that leads to bloated interface

files which is ultimately quadratic for Nested CPR.

So we don't attach any CPR signature to bindings that

  * Are not thunks (because thunks are not in WHNF)

  * Have arity 0 (which means the top-level constructor is not a lambda)

If the data structure has an unfolding, we continue to look through it.

If not (as is the case for `KindRep`s), we look at the unchanged CPR

signature and see `topCprType`, as expected.

</pre>

</li>

<li>

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

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-10-01T18:37:23-04:00</i>

</div>

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

Close #18755

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-01T18:37:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix pretty-printing of the mult-polymorphic arrow

A follow-up to !4020 (5830a12c46e7227c276a8a71213057595ee4fc04)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-01T18:38:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: add integerNegate RULE

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-01T18:39:10-04:00</i>

</div>

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

It did not do any useful work.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-02T08:00:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typos in comments

[skip ci]

</pre>

</li>

<li>

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

<div>

<span>by Icelandjack</span>

<i>at 2020-10-02T08:01:01-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Replaced MkT1 with T1 in type signatures.</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-02T13:51:58-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Minor TTG clean-up: comments, unused families, bottom

1. Fix and update section headers in GHC/Hs/Extension.hs

2. Delete the unused 'XCoreAnn' and 'XTickPragma' families

3. Avoid calls to 'panic' in 'pprStmt'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12c06927a03a2fdb516f7008c57d68568b02b576">12c06927</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-02T13:52:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement integerRecipMod (#18427)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-02T13:52:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: implement integerPowMod (#18427)

Incidentally fix powModInteger which was crashing in integer-gmp for

negative exponents when the modular multiplicative inverse for the base

didn't exist. Now we compute it explicitly with integerRecipMod so that

every backend returns the same result without crashing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/1033a720abf4a23a30c5cb0dfcb18b2bae3acc68">1033a720</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-02T13:53:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Reject linearity in kinds in checkValidType (#18780)

Patch taken from https://gitlab.haskell.org/ghc/ghc/-/issues/18624#note_300673

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-03T19:33:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Small documentation fixes

- Fix formatting of code blocks and a few sphinx warnings

- Move the Void# change to 9.2, it was done right after the branch was cut

- Fix typo in linear types documentation

- Note that -Wincomplete-uni-patterns affects lazy patterns

[skip ci]

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/70dc2f09a33a4c3f485d8b63e92a21955643a0b7">70dc2f09</a></strong>

<div>

<span>by Karel Gardas</span>

<i>at 2020-10-03T19:33:06-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">fix rts.cabal to use real arch names and not aliasses (fixes #18654)

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Inline `integerDecodeDouble#` and constant-fold `decodeDouble_Int64#` instead

Currently, `integerDecodeDouble#` is known-key so that it can be

recognised in constant folding. But that is very brittle and doesn't

survive worker/wrapper, which we even do for

`NOINLINE` things since #13143.

Also it is a trade-off: The implementation of `integerDecodeDouble#`

allocates an `Integer` box that never cancels aways if we don't inline

it.

Hence we recognise the `decodeDouble_Int64#` primop instead in constant

folding, so that we can inline `integerDecodeDouble#`. As a result,

`integerDecodeDouble#` no longer needs to be known-key.

While doing so, I realised that we don't constant-fold

`decodeFloat_Int#` either, so I also added a RULE for it.

`integerDecodeDouble` is dead, so I deleted it.

Part of #18092. This improves the 32-bit `realToFrac`/`toRational`:

Metric Decrease:

    T10359

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/802b5e6fdd6dfc58396a9dca1903dc5a1d6634ca">802b5e6f</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix linear types in TH splices (#18465)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/18a3ddf75d25094096a7fe44fd250de973041187">18a3ddf7</a></strong>

<div>

<span>by Ben Gamari</span>

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

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Fix integer width in TICK_BUMP_BY

Previously `TICK_BUMP_BY` was defined as

```c

 #define TICK_BUMP_BY(ctr,n) CLong[ctr] = CLong[ctr] + n

```

Yet the tickers themselves were defined as `StgInt`s. This happened to

work out correctly on Linux, where `CLong` is 64-bits. However, it

failed on Windows, where `CLong` is 32-bits, resulting in #18782.

Fixes #18783.

</pre>

</li>

<li>

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

<div>

<span>by Rachel</span>

<i>at 2020-10-07T14:59:45-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document profiling flags, warning flags, and no-pie

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-07T15:00:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">WinIO: Small changes related to atomic request swaps.

Move the atomix exchange over the Ptr type to an internal module.

Fix a bug caused by us passing ptr-to-ptr instead of ptr to

atomic exchange.

Renamed interlockedExchange to exchangePtr.

I've also added an cas primitive. It turned out we don't need it

for WinIO but I'm leaving it in as it's useful for other things.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/948a14e1eaaf0c033e3f19d1b9eecb398ddc8661">948a14e1</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-07T15:00:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix name of Ubuntu 20.04 image</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74d4017b744585a89709ac4b74dbe37b44741464">74d4017b</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-07T15:01:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix -flink-rts (#18651)

Before this patch -flink-rts could link with GHC's rts instead of the

selected one.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-07T15:01:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to compiler/GHC/SysTools.hs</pre>

</li>

<li>

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

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-07T15:02:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Preserve as-parsed arrow type for HsUnrestrictedArrow

When linear types are disabled, HsUnrestrictedArrow is treated as

HslinearArrow.

Move this adjustment into the type checking phase, so that the parsed

source accurately represents the source as parsed.

Closes #18791

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/030c5ce0a58e212eb7b973e1206b775085b74afb">030c5ce0</a></strong>

<div>

<span>by Karel Gardas</span>

<i>at 2020-10-07T15:02:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: use stage0 linker to merge objects when done during the stage0

Fixes #18800.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-07T15:03:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Allow whitespace before "Metric (in|de)crease"

Several people have struggled with metric change annotations

in their commit messages not being recognized due to the fact that

GitLab's job log inserts a space at the beginning of each line. Teach

the regular expression to accept this whitespace.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-07T15:04:07-04:00</i>

</div>

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

* Include funTyCon in exposedPrimTyCons.

  Every single place using exposedPrimTyCons was adding funTyCon

  manually.

* Remove unused synTyConResKind and ieLWrappedName

* Add recordSelectorTyCon_maybe

* In exprType, panic instead of giving a trace message and dummy output.

  This prevents #18767 reoccurring.

* Fix compilation error in fragile concprog001 test (part of #18732)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/386c2d7ff80843051ad15eab5de3766430ee98a5">386c2d7f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:40:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use UnitId in the backend instead of Unit

In Cmm we can only have real units identified with an UnitId.  Other

units (on-the-fly instantiated units and holes) are only used in

type-checking backpack sessions that don't produce Cmm.

</pre>

</li>

<li>

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

<div>

<span>by Simon Jakobi</span>

<i>at 2020-10-09T08:41:09-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Update containers to v0.6.4.1

Updates containers submodule.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:41:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: fix race condition in StgCRun

On windows the stack has to be allocated 4k at a time, otherwise we get

a segfault. This is done by using a helper ___chkstk_ms that is provided

by libgcc. The Haskell side already knows how to handle this but we need

to do the same from STG. Previously we would drop the stack in StgRun

but would only make it valid whenever the scheduler loop ran.

This approach was fundamentally broken in that it falls apart when you

take a signal from the OS. We see it less often because you initially

get allocated a 1MB stack block which you have to blow past first.

Concretely this means we must always keep the stack valid.

Fixes #18601.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:42:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Expose RTS-only ways (#18651)

Some RTS ways are exposed via settings (ghcThreaded, ghcDebugged) but

not all. It's simpler if the RTS exposes them all itself.

</pre>

</li>

<li>

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

<div>

<span>by MaxGabriel</span>

<i>at 2020-10-09T08:43:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Document -Wderiving-typeable

Tracking: #18641

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:43:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add a flag to indicate that gcc supports -no-pie

Fixes #17919.

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-10-09T08:44:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add linting of `base` to the CI

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/45a1d493ec877f5fa0b3228deee3e019033c89db">45a1d493</a></strong>

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:45:05-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use proper RTS flags when collecting residency in perf tests.

Replace options like collect_stats(['peak_megabytes_allocated'],4) with

collect_runtime_residency(4) and so forth. Reason being that the later

also supplies some default RTS arguments which make sure residency does

not fluctuate too much.

The new flags mean we get new (hopefully more accurate) baselines so

accept the stat changes.

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

Metric Decrease:

     T4029

     T4334

     T7850

Metric Increase:

     T13218

     T7436

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

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:45:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite/timeout: Fix windows specific errors.

We now seem to use -Werror there. Which caused some long standing

warnings to become errors.

I applied changes to remove the warnings allowing the testsuite to

run on windows as well.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:46:22-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Hadrian: add quick-debug flavour

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/12191a99d3b978b697ec0fb4412276fbea5dce8f">12191a99</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:47:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: match on small Integer/Natural

Previously we only matched on *variables* whose unfoldings were a ConApp

of the form `IS lit#` or `NS lit##`. But we forgot to match on the

ConApp directly... As a consequence, constant folding only worked after

the FloatOut pass which creates bindings for most sub-expressions. With

this patch, matching on bignums works even with -O0 (see bignumMatch

test).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/36787bba78ae5acbb857c84b85b8feb7c83e54a5">36787bba</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-09T08:47:36-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ApiAnnotations : preserve parens in GADTs

A cleanup in 7f418acf61e accidentally discarded some parens in

ConDeclGADT.

Make sure these stay in the AST in a usable format.

Also ensure the AnnLolly does not get lost in a GADT.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/32dc7698a0c38afe2889119a2df0f2a2b8debe0a">32dc7698</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:48:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix roles in GADTs (#18799)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9657f6f34a1a00008a0db935dbf25733cb483cd4">9657f6f3</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-09T08:48:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">sdist: Include hadrian sources in source distribution

Previously the make build system's source distribution rules neglected

to include Hadrian's sources.

Fixes #18794.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:49:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed timeouts non-threaded.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:50:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fix array splat

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:50:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed bytestring reading interface.

</pre>

</li>

<li>

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

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-09T08:51:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: fixed more data error.

</pre>

</li>

<li>

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

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-09T08:52:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix desugaring of record updates on data families

This fixes a long-standing bug in the desugaring of record

updates for data families, when the latter involves a GADT. It's

all explained in Note [Update for GADTs] in GHC.HsToCore.Expr.

Building the correct cast is surprisingly tricky, as that Note

explains.

Fixes #18809.  The test case (in indexed-types/should_compile/T18809)

contains several examples that exercise the dark corners.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-09T08:52:43-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump win32-tarballs version to 0.3

This should fix #18774.

</pre>

</li>

<li>

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

<div>

<span>by Andreas Klebinger</span>

<i>at 2020-10-09T08:53:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add TyCon Set/Env and use them in a few places.

Firstly this improves code clarity.

But it also has performance benefits as we no longer

go through the name of the TyCon to get at it's unique.

In order to make this work the recursion check for TyCon

has been moved into it's own module in order to avoid import

cycles.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-09T08:54:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add -pgmlm and -optlm flags

!3798 added documentation and semantics for the flags,

but not parsing.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:54:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Testsuite: increase timeout for T18223 (#18795)

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-09T08:55:21-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Cache HomeUnit in HscEnv (#17957)

Instead of recreating the HomeUnit from the DynFlags every time we need

it, we store it in the HscEnv.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/5884fd325248e75d40c9da431b4069e43a2c182c">5884fd32</a></strong>

<div>

<span>by Fendor</span>

<i>at 2020-10-09T19:46:28+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move File Target parser to library #18596

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-10-10T14:49:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Lint the compiler for extraneous LANGUAGE pragmas

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-10T14:50:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Linear types: fix quantification in GADTs (#18790)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/74ee1237bf243dd7d8b758a53695575c364c3088">74ee1237</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-10T14:51:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bignum: fix bigNatCompareWord# bug (#18813)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/274e21f02fabb4b3761841972b1074d0c0146fae">274e21f0</a></strong>

<div>

<span>by Hécate</span>

<i>at 2020-10-11T10:55:56+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove the dependency on the ghc-linters stage

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/990ea991a1c35fdb894fcb91f919fb8f8fed33dd">990ea991</a></strong>

<div>

<span>by Daniel Rogozin</span>

<i>at 2020-10-11T22:20:04+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fall back to types when looking up data constructors (#18740)

Before this patch, referring to a data constructor in a term-level

context led to a scoping error:

    ghci> id Int

    <interactive>:1:4: error: Data constructor not in scope: Int

After this patch, the renamer falls back to the type namespace

and successfully finds the Int. It is then rejected in the type

checker with a more useful error message:

    <interactive>:1:4: error:

    • Illegal term-level use of the type constructor ‘Int’

        imported from ‘Prelude’ (and originally defined in ‘GHC.Types’)

    • In the first argument of ‘id’, namely ‘Int’

      In the expression: id Int

We also do this for type variables.

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-12T18:21:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DynFlags: refactor DmdAnal

Make demand analysis usable without having to provide DynFlags.

</pre>

</li>

<li>

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

<div>

<span>by Wander Hillen</span>

<i>at 2020-10-13T00:12:47-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Initial ShortText code and conversion of package db code

Metric Decrease:

    Naperian

    T10421

    T10421a

    T10547

    T12150

    T12234

    T12425

    T13035

    T18140

    T18304

    T5837

    T6048

    T13253-spj

    T18282

    T18223

    T3064

    T9961

Metric Increase

    T13701

HFSKJH

</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-13T00:13:28-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser: don't require the HomeUnitId

The HomeUnitId is only used by the Cmm parser and this one has access to

the DynFlags, so it can grab the UnitId of the HomeUnit from them.

Bump haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by HaskellMouse</span>

<i>at 2020-10-13T13:05:49+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Unification of Nat and Naturals

This commit removes the separate kind 'Nat' and enables promotion

of type 'Natural' for using as type literal.

It partially solves #10776

Now the following code will be successfully typechecked:

    data C = MkC Natural

    type CC = MkC 1

Before this change we had to create the separate type for promotion

    data C = MkC Natural

    data CP = MkCP Nat

    type CC = MkCP 1

But CP is uninhabited in terms.

For backward compatibility type synonym `Nat` has been made:

    type Nat = Natural

The user's documentation and tests have been updated.

The haddock submodule also have been updated.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T03:42:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Verify that Hadrian builds with Stack

As noted in #18726, this regularly breaks. Let's test it.

Note that we don't actually perform a build of GHC itself; we merely

test that the Hadrian executable builds and works (by invoking `hadrian

--version`).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/89f4d8e950a1ed2a3ffab424233d3bcd243b1771">89f4d8e9</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T12:03:57-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Bump LLVM version to 10.0

Fixes #18267.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/716385c90f2f89ac45e256cdb7cdada1981b31ad">716385c9</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-14T12:04:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make DataKinds the sole arbiter of kind-level literals (and friends)

Previously, the use of kind-level literals, promoted tuples,

and promoted lists required enabling both `DataKinds` and

`PolyKinds`. This made sense back in a `TypeInType` world, but not so

much now that `TypeInType`'s role has been superseded. Nowadays,

`PolyKinds` only controls kind polymorphism, so let's make `DataKinds`

the thing that controls the other aspects of `TypeInType`, which include

literals, promoted tuples and promoted lists.

There are some other things that overzealously required `PolyKinds`,

which this patch fixes as well:

* Previously, using constraints in kinds (e.g., `data T :: () -> Type`)

  required `PolyKinds`, despite the fact that this is orthogonal to kind

  polymorphism. This now requires `DataKinds` instead.

* Previously, using kind annotations in kinds

  (e.g., `data T :: (Type :: Type) -> Type`) required both `KindSignatures`

  and `PolyKinds`. This doesn't make much sense, so it only requires

  `KindSignatures` now.

Fixes #18831.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-14T12:05:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove "Operator sections" from docs/users_guide/bugs.rst

The issue described in that section was fixed by

2b89ca5b850b4097447cc4908cbb0631011ce979

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-14T12:05:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix PostfixOperators (#18151)

This fixes a regression introduced in 2b89ca5b850b4097447cc4908cbb0631011ce979

See the new T18151x test case.

</pre>

</li>

<li>

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

<div>

<span>by Fumiaki Kinoshita</span>

<i>at 2020-10-14T18:06:12-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add -Wnoncanonical-{monad,monoid}-instances to standardWarnings

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

Metric Decrease:

   T12425

Metric Increase:

   T17516

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

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/15d2340cb9dc833adb87784e6de86dba235290f7">15d2340c</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-14T18:06:48-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix some missed opportunities for preInlineUnconditionally

There are two signficant changes here:

* Ticket #18815 showed that we were missing some opportunities for

  preInlineUnconditionally.  The one-line fix is in the code for

  GHC.Core.Opt.Simplify.Utils.preInlineUnconditionally, which now

  switches off only for INLINE pragmas.  I expanded

  Note [Stable unfoldings and preInlineUnconditionally] to explain.

* When doing this I discovered a way in which preInlineUnconditionally

  was occasionally /too/ eager.  It's all explained in

  Note [Occurrences in stable unfoldings] in GHC.Core.Opt.OccurAnal,

  and the one-line change adding markAllMany to occAnalUnfolding.

I also got confused about what NoUserInline meant, so I've renamed

it to NoUserInlinePrag, and changed its pretty-printing slightly.

That led to soem error messate wibbling, and touches quite a few

files, but there is no change in functionality.

I did a nofib run.  As expected, no significant changes.

        Program           Size    Allocs

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

         sphere          -0.0%     -0.4%

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

            Min          -0.0%     -0.4%

            Max          -0.0%     +0.0%

 Geometric Mean          -0.0%     -0.0%

I'm allowing a max-residency increase for T10370, which seems

very irreproducible. (See comments on !4241.)  There is always

sampling error for max-residency measurements; and in any case

the change shows up on some platforms but not others.

Metric Increase:

    T10370

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-14T18:07:25-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Add missing :ghc-flag: directive</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/51c4b851965abdece2f88f8e583256e15f3140fe">51c4b851</a></strong>

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-15T04:30:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove Proxy# argument in Data.Typeable.Internal

No longer neccessary - TypeRep is now indexed, there is no ambiguity.

Also fix a comment in Evidence.hs, IsLabel no longer takes a Proxy#.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/809f09e8a7060691b1f2f5d6b95ca75e66437e55">809f09e8</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-15T04:31:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix parsing of PIE flags

-fPIE and -fno-PIE flags were (un)setting Opt_PIC instead of Opt_PIE.

Original commit: 3625728a0e3a9b56c2b85ae7ea8bcabdd83ece6a

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T04:31:42-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add missing #include on <stdlib.h>

This otherwise fails on newer Clangs, which warn

more aggressively on undeclared symbols.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/998803dc4dbceb36074644483e11e6183fa5355a">998803dc</a></strong>

<div>

<span>by Andrzej Rybczak</span>

<i>at 2020-10-15T11:40:32+02:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add flags for annotating Generic{,1} methods INLINE[1] (#11068)

Makes it possible for GHC to optimize away intermediate Generic representation

for more types.

Metric Increase:

    T12227

</pre>

</li>

<li>

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

<div>

<span>by GHC GitLab CI</span>

<i>at 2020-10-15T21:57:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Extend mAX_TUPLE_SIZE to 64

As well a ctuples and sums.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Clean-up whitespace in Interpreter

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Use strict Maps in bytecode assembler

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Make LocalLabel a newtype

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-15T21:58:27-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">compiler/ByteCode: Allow 2^32 local labels

This widens LocalLabel to 2^16, avoiding the crash observed in #14334.

Closes #14334.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">mingw: Extract zst toolchain archives

This should have been done when the toolchain was bumped.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">base: Reintroduce necessary LANGUAGE pragmas

These were incorrectly removed in a recent cleanup commit.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Sort metrics by metric type

Closes #18838.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Account for -Wnoncanonical-monoid-instances changes on Windows

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/330a5433b709c0cc16eb5fe9a06c21f4b2009be7">330a5433</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">rts: Add __mingw_vfprintf to RtsSymbols.c

Following the model of the other printf symbols. See Note [Symbols for

MinGW's printf].

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Remove allow_failure from Windows jobs

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-16T00:15:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Fix Hadrian bindist names

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/07b0db86595890dfca6f624e554cdb8c9b86d0cc">07b0db86</a></strong>

<div>

<span>by f-a</span>

<i>at 2020-10-16T10:14:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Clarify Eq documentation #18713</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-17T10:20:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Allow doc-tarball job to fail

Currently the Hadrian build appears not to package documentation correctly,

causing doc-tarball to fail due to the Windows build.</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-17T13:26:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: s/allow_newer/allow_failure

Silly mistake on my part.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/59d7c9f45b034809516703b57c84e3dac1834578">59d7c9f4</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-10-17T22:01:38-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Skip type family defaults with hs-boot and hsig files

Works around #17190, possible resolution for #17224. New design is is

according to accepted [GHC Propoal 320].

Instances in signatures currently unconditionally opt into associated

family defaults if no explicit instance is given. This is bad for two

reasons:

  1. It constrains possible instantiations to use the default, rather

  than possibly define the associated family differently.

  2. It breaks compilation as type families are unsupported in

  signatures.

This PR simply turns off the filling in of defaults in those cases.

Additionally, it squelches a missing definition warning for hs-boot too

that was only squelched for hsig before.

The downsides are:

  1. There is no way to opt into the default, other than copying its

  definition.

  2. If we fixed type classes in signatures, and wanted instances to

  have to explicitly *out of* rather than into the default, that would

  now be a breaking change.

The change that is most unambiguously goood is harmonizing the warning

squelching between hs-boot or hsig. Maybe they should have the warning

(opt out of default) maybe they shouldn't (opt in to default), but

surely it should be the same for both.

Add hs-boot version of a backpack test regarding class-specified

defaults in instances that appear in an hs-boot file.

The metrics increase is very slight and makes no sense --- at least no

one has figured anything out after this languishing for a while, so I'm

just going to accept it.

Metric Increase:

  T10421a

[GHC proposal 320]: https://github.com/ghc-proposals/ghc-proposals/pull/320

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Refactor fixed-point iteration in GHC.Core.Opt.Arity

Arity analysis used to propagate optimistic arity types during

fixed-point interation through the `ArityEnv`'s `ae_cheap_fun` field,

which is like `GHC.Core.Utils.exprIsCheap`, but also considers the

current iteration's optimistic arity, for the binder in question only.

In #18793, we have seen that this is a problematic design, because it

doesn't allow us to look through PAP bindings of that binder.

Hence this patch refactors to a more traditional form with an explicit

signature environment, in which we record the optimistic `ArityType` of

the binder in question (and at the moment is the *only* binder that is

recorded in the arity environment).

</pre>

</li>

<li>

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

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Arity: Record arity types for non-recursive lets

In #18793, we saw a compelling example which requires us to look at

non-recursive let-bindings during arity analysis and unleash their arity

types at use sites.

After the refactoring in the previous patch, the needed change is quite

simple and very local to `arityType`'s defn for non-recurisve `Let`.

Apart from that, we had to get rid of the second item of

`Note [Dealing with bottoms]`, which was entirely a safety measure and

hindered optimistic fixed-point iteration.

Fixes #18793.

The following metric increases are all caused by this commit and a

result of the fact that we just do more work now:

Metric Increase:

    T3294

    T12545

    T12707

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/451455fd008500259f5d2207bdfdccf6dddb52c5">451455fd</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-17T22:02:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Testsuite: Add dead arity analysis tests

We didn't seem to test these old tests at all, judging from their

expected output.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/50e9df49b7cd637c4552ab34bf629a01af4767c0">50e9df49</a></strong>

<div>

<span>by Dylan Yudaken</span>

<i>at 2020-10-17T22:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">When using rts_setInCallCapability, lock incall threads

This diff makes sure that incall threads, when using `rts_setInCallCapability`, will be created as locked.

If the thread is not locked, the thread might end up being scheduled to a different capability.

While this is mentioned in the docs for `rts_setInCallCapability,`, it makes the method significantly less useful as there is no guarantees on the capability being used.

This commit also adds a test to make sure things stay on the correct capability.

</pre>

</li>

<li>

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

<div>

<span>by DylanZA</span>

<i>at 2020-10-17T22:02:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Apply suggestion to testsuite/tests/ffi/should_run/all.T</pre>

</li>

<li>

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

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-17T22:04:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Don't get host RTS ways via settings (#18651)

To correctly perform a linking hack for Windows we need to link with the

RTS GHC is currently using. We used to query the RTS ways via the

"settings" file but it is fragile (#18651). The hack hasn't been fixed

to take into account all the ways (Tracing) and it makes linking of GHC

with another RTS more difficult (we need to link with another RTS and to

regenerate the settings file).

So this patch uses the ways reported by the RTS itself

(GHC.Platform.Ways.hostWays) instead of the "settings" file.

</pre>

</li>

<li>

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

<div>

<span>by Hécate</span>

<i>at 2020-10-17T22:04:38-04:00</i>

</div>

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

* Bring back LANGUAGE pragmas in GHC.IO.Handle.Lock.Windows

* Exclude some modules that are wrongfully reported

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-19T18:16:20-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Implement -Woperator-whitespace (#18834)

This patch implements two related warnings:

  -Woperator-whitespace-ext-conflict

      warns on uses of infix operators that would be parsed

      differently were a particular GHC extension enabled

  -Woperator-whitespace

      warns on prefix, suffix, and tight infix uses of infix

      operators

Updates submodules: haddock, containers.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9648d680b4b07d48cf8741e0847abf07b95c7c1d">9648d680</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-19T18:16:58-04:00</i>

</div>

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

pdocPrec was only used in GHC.Cmm.DebugBlock.pprUnwindExpr, so remove

it. OutputableP becomes a one-function class which might be better for

performance.

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T00:47:54-04:00</i>

</div>

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

This was fixed by 4291bddaea3148908c55f235ee8978e1d9aa6f20.

</pre>

</li>

<li>

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

<div>

<span>by Krzysztof Gogolewski</span>

<i>at 2020-10-20T00:48:29-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Minor comments, update linear types docs

- Update comments: placeHolderTypeTc no longer exists

  "another level check problem" was a temporary comment from linear types

- Use Mult type synonym (reported in #18676)

- Mention multiplicity-polymorphic fields in linear types docs

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/58a1ca3886b00630937d7f5073b2d7961f8e80ca">58a1ca38</a></strong>

<div>

<span>by nineonine</span>

<i>at 2020-10-20T00:49:07-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Compile modules with `-fobject-code` enabled to byte-code when loaded with `*` prefix in ghci (#8042)

The documentation states that when using :add and :load, the `*` prefix forces a module

to be loaded as byte-code. However, this seems to be ignored when -fobject-code has been

enabled. In that case, the compiled code is always used, regardless of whether the *-form

is used.

The idea is to consult the Targets in HscEnv and check the 'targetAllowObjCode' flag. If

the flag for given module is set, then patch up DynFlags and select compilation backend

accordingly.

This would require a linear scan of course, but that shouldn't be too costly.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/59b08a5d192e102f66a6d9260cc8466d7428cffe">59b08a5d</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T00:49:41-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Rename FLAVOUR -> BUILD_FLAVOUR

Previously the Hadrian jobs used the `FLAVOUR` environment variable to

communicate which flavour `ci.sh` should build whereas `make` used

`BUILD_FLAVOUR`. This caused unnecessary confusion. Consolidate these

two.

</pre>

</li>

<li>

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

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-20T08:35:34+01:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">API Annotations: Keep track of unicode for linear arrow notation

The linear arrow can be parsed as `%1 ->` or a direct single token unicode

equivalent.

Make sure that this distinction is captured in the parsed AST by using

IsUnicodeSyntax where it appears, and introduce a new API Annotation,

AnnMult to represent its location when unicode is not used.

Updated haddock submodule

</pre>

</li>

<li>

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

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-20T22:56:31-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T12971 as fragile on Windows

Due to #17945.

</pre>

</li>

<li>

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

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-21T16:00:30+03:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Parser regression tests, close #12862 #12446

These issues were fixed by earlier parser changes, most likely related

to whitespace-sensitive parsing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/711929e6bcbcd5439dbf748cb57f56088b9a9f16">711929e6</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-23T02:42:59-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix error message location in tcCheckPatSynDecl

Ticket #18856 showed that we were failing to set the right location

for an error message.  Easy to fix, happily.

Turns out that this also improves the error location in test T11010,

which was bogus before but we had never noticed.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/730bb59086ad1036143983c3fba61bd851bebc03">730bb590</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-23T02:43:33-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">cmm: Add Note reference to ForeignHint</pre>

</li>

<li>

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

<div>

<span>by David Beacham</span>

<i>at 2020-10-27T13:59:35-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix `instance Bounded a => Bounded (Down a)` (#18716)

* Flip `minBound` and `maxBound` to respect the change in ordering

* Remove awkward `Enum` (and hence `Integral`) instances for

  `Data.Ord.Down`

* Update changelog

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/eedec53df8bf030b36cdd1fcfd1ff06041bc46fd">eedec53d</a></strong>

<div>

<span>by Vladislav Zavialov</span>

<i>at 2020-10-27T14:00:11-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Version bump: base-4.16 (#18712)

Also bumps upper bounds on base in boot libraries (incl. submodules).

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/412018c1214a19649e0ccfff73e80a0622635dd5">412018c1</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-27T14:00:49-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: simplify logic remove optimization step.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/4950dd075ce79e13d24362d669e134ed5a4ddec7">4950dd07</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:01:24-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Suppress xelatex output unless it fails

As noted in #18835, xelatex produces an absurd amount of output, nearly

all of which is meaningless. Silence this.

Fixes #18835.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f3d8ab2ef6ffe30ec91c795e0223392dd96ea61a">f3d8ab2e</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:02:00-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">build system: Clean mingw tarballs

Tamar noticed in !4293 that the build systems fail to clean up the mingw

tarballs directory (`ghc-tarballs`). Fix this in both the make build

system and Hadrian.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0b3d23afcad8bc14f2ba69b8dbe05c314e6e7b29">0b3d23af</a></strong>

<div>

<span>by Simon Peyton Jones</span>

<i>at 2020-10-27T14:02:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix two constraint solving problems

This patch fixes two problems in the constraint solver.

* An actual bug #18555: we were floating out a constraint to eagerly,

  and that was ultimately fatal.  It's explained in

  Note [Do not float blocked constraints] in GHC.Core.Constraint.

  This is all very delicate, but it's all going to become irrelevant

  when we stop floating constraints (#17656).

* A major performance infelicity in the flattener.  When flattening

  (ty |> co) we *never* generated Refl, even when there was nothing

  at all to do.  Result: we would gratuitously rewrite the constraint

  to exactly the same thing, wasting work.  Described in #18413, and

  came up again in #18855.

  Solution: exploit the special case by calling the new function

  castCoercionKind1.  See Note [castCoercionKind1] in

  GHC.Core.Coercion

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/f76c5a083edc62bb40efbb0e76e8a3bf50ead765">f76c5a08</a></strong>

<div>

<span>by Sergei Trofimovich</span>

<i>at 2020-10-27T14:03:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc.mk: amend 'make sdist'

Noticed 'make sdist' failure seen as:

```

"rm" -rf sdistprep/ghc/ghc-9.1.0.20201020/hadrian/_build/ (SRC_DIST_GHC_DIR)/hadrian/dist-newstyle/

/bin/sh: -c: line 0: syntax error near unexpected token `('

```

commit 9657f6f34

("sdist: Include hadrian sources in source distribution")

added a new cleanup path without a variable expantion.

The change adds variable reference. While at it move directory

cleanup to a separate statement.

Amends #18794

Signed-off-by: Sergei Trofimovich <slyfox@gentoo.org>

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/78b52c888a1cc68750261382e3a62fff65242016">78b52c88</a></strong>

<div>

<span>by David Eichmann</span>

<i>at 2020-10-27T14:03:51-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Use config.run_ways for multi_compile_and_run tests

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/e3fdd4197cd9def4af40acb3753843e3e9a74d7e">e3fdd419</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-27T14:04:26-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Api Annotations: Introduce AnnPercent for HsExplicitMult

For the case

  foo :: a %p -> b

The location of the '%' is captured, separate from the 'p'

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d2a25f42f884ad4ac841a36474498131596da506">d2a25f42</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-27T14:05:02-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Bump ci-images

Bumps bootstrap compiler to 8.10.1.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/28f98b01d055c8027f9495b1669bf875b3e42168">28f98b01</a></strong>

<div>

<span>by Sebastian Graf</span>

<i>at 2020-10-27T14:05:37-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">DmdAnal: Kill `is_thunk` case in `splitFV`

The `splitFV` function implements the highly dubious hack

described in `Note [Lazy und unleashable free variables]` in

GHC.Core.Opt.DmdAnal. It arranges it so that demand signatures only

carry strictness info on free variables. Usage info is released through

other means, see the Note. It's purely for analysis performance reasons.

It turns out that `splitFV` has a quite involved case for thunks that

produces slightly different usage signatures and it's not clear why we

need it: `splitFV` is only relevant in the LetDown case and the only

time we call it on thunks is for top-level or local recursive thunks.

Since usage signatures of top-level thunks can only reference other

top-level bindings and we completely discard demand info we have on

top-level things (see the lack of `setIdDemandInfo` in

`dmdAnalTopBind`), the `is_thunk` case is completely irrelevant here.

For local, recursive thunks, the added benefit of the `is_thunk` test

is marginal: We get used-multiple-times in some cases where previously

we had used-once if a recursive thunk has multiple call sites. It's

very unlikely and not a case to optimise for.

So we kill the `is_thunk` case and inline `splitFV` at its call site,

exposing `isWeakDmd` from `GHC.Types.Demand` instead.

The NoFib summary supports this decision:

```

            Min           0.0%     -0.0%

            Max           0.0%     +0.0%

 Geometric Mean          -0.0%     -0.0%

```

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/60322f930c544fabd7e68231db26e3a1fb8ed037">60322f93</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-28T21:11:39-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">hadrian: Don't quote metric baseline argument

Previously this was quoted inappropriately.</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/c85eb3722bc68999dee023c98a8da0ffbbd89760">c85eb372</a></strong>

<div>

<span>by Alan Zimmerman</span>

<i>at 2020-10-28T21:12:15-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">API Annotations: put constructors in alphabetical order

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/795908dc4eab8e8b40cb318a2adbe4a4d4126c74">795908dc</a></strong>

<div>

<span>by John Ericson</span>

<i>at 2020-10-29T03:53:14-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Widen acceptance threshold for T10421a

Progress towards #18842. As @sgraf812 points out, widening the window is

dangerous until the exponential described in #17658 is fixed. But this

test has caused enough misery and is low stakes enough that we and

@bgamari think it's worth it in this one case for the time being.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/0e9f6defbdc1f691ff7197b21e68ac16ffa4ab59">0e9f6def</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-29T03:53:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Split GHC.Driver.Types

I was working on making DynFlags stateless (#17957), especially by

storing loaded plugins into HscEnv instead of DynFlags. It turned out to

be complicated because HscEnv is in GHC.Driver.Types but LoadedPlugin

isn't: it is in GHC.Driver.Plugins which depends on GHC.Driver.Types. I

didn't feel like introducing yet another hs-boot file to break the loop.

Additionally I remember that while we introduced the module hierarchy

(#13009) we talked about splitting GHC.Driver.Types because it contained

various unrelated types and functions, but we never executed. I didn't

feel like making GHC.Driver.Types bigger with more unrelated Plugins

related types, so finally I bit the bullet and split GHC.Driver.Types.

As a consequence this patch moves a lot of things. I've tried to put

them into appropriate modules but nothing is set in stone.

Several other things moved to avoid loops.

* Removed Binary instances from GHC.Utils.Binary for random compiler

  things

* Moved Typeable Binary instances into GHC.Utils.Binary.Typeable: they

  import a lot of things that users of GHC.Utils.Binary don't want to

  depend on.

* put everything related to Units/Modules under GHC.Unit:

  GHC.Unit.Finder, GHC.Unit.Module.{ModGuts,ModIface,Deps,etc.}

* Created several modules under GHC.Types: GHC.Types.Fixity, SourceText,

  etc.

* Split GHC.Utils.Error (into GHC.Types.Error)

* Finally removed GHC.Driver.Types

Note that this patch doesn't put loaded plugins into HscEnv. It's left

for another patch.

Bump haddock submodule

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/22f5d9a951dbc9cfdf55984c5e2a6fad28a6f650">22f5d9a9</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-29T03:53:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">GC: Avoid data race (#18717, #17964)

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/2ef2fac4c412a25fa64f79b759d69d22a4ebc784">2ef2fac4</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-29T04:18:52-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Check for large tuples more thoroughly

This fixes #18723 by:

* Moving the existing `GHC.Tc.Gen.HsType.bigConstraintTuple` validity

  check to `GHC.Rename.Utils.checkCTupSize` for consistency with

  `GHC.Rename.Utils.checkTupSize`, and

* Using `check(C)TupSize` when checking tuple _types_, in addition

  to checking names, expressions, and patterns.

Note that I put as many of these checks as possible in the typechecker so

that GHC can properly distinguish between boxed and constraint tuples. The

exception to this rule is checking names, which I perform in the renamer

(in `GHC.Rename.Env`) so that we can rule out `(,, ... ,,)` and

`''(,, ... ,,)` alike in one fell swoop.

While I was in town, I also removed the `HsConstraintTuple` and

`HsBoxedTuple` constructors of `HsTupleSort`, which are functionally

unused. This requires a `haddock` submodule bump.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/7f8be3eb3440a152246a1aef7b4020be4c03cf2e">7f8be3eb</a></strong>

<div>

<span>by Richard Eisenberg</span>

<i>at 2020-10-29T22:08:13-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Remove unnecessary gender from comments/docs

While, say, alternating "he" and "she" in sequential writing

may be nicer than always using "they", reading code/documentation

is almost never sequential. If this small change makes individuals

feel more welcome in GHC's codebase, that's a good thing.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/9902d9ec95dfc3ddb3e8a703de6b000c3ac3871a">9902d9ec</a></strong>

<div>

<span>by Viktor Dukhovni</span>

<i>at 2020-10-30T05:28:30-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">[skip ci] Fix typo in `callocBytes` haddock.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/31fcb55f4ff8c06c5ab100a6817cae8b571295a9">31fcb55f</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-30T18:52:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Split HsConDecl{H98,GADT}Details

Haskell98 and GADT constructors both use `HsConDeclDetails`, which includes

`InfixCon`. But `InfixCon` is never used for GADT constructors, which results

in an awkward unrepresentable state. This removes the unrepresentable state by:

* Renaming the existing `HsConDeclDetails` synonym to `HsConDeclH98Details`,

  which emphasizes the fact that it is now only used for Haskell98-style data

  constructors, and

* Creating a new `HsConDeclGADTDetails` data type with `PrefixConGADT` and

  `RecConGADT` constructors that closely resemble `PrefixCon` and `InfixCon`

  in `HsConDeclH98Details`. The key difference is that `HsConDeclGADTDetails`

  lacks any way to represent infix constructors.

The rest of the patch is refactoring to accommodate the new structure of

`HsConDecl{H98,GADT}Details`. Some highlights:

* The `getConArgs` and `hsConDeclArgTys` functions have been removed, as

  there is no way to implement these functions uniformly for all

  `ConDecl`s. For the most part, their previous call sites now

  pattern match on the `ConDecl`s directly and do different things for

  `ConDeclH98`s and `ConDeclGADT`s.

  I did introduce one new function to make the transition easier:

  `getRecConArgs_maybe`, which extracts the arguments from a `RecCon(GADT)`.

  This is still possible since `RecCon(GADT)`s still use the same representation

  in both `HsConDeclH98Details` and `HsConDeclGADTDetails`, and since the

  pattern that `getRecConArgs_maybe` implements is used in several places,

  I thought it worthwhile to factor it out into its own function.

* Previously, the `con_args` fields in `ConDeclH98` and `ConDeclGADT` were

  both of type `HsConDeclDetails`. Now, the former is of type

  `HsConDeclH98Details`, and the latter is of type `HsConDeclGADTDetails`,

  which are distinct types. As a result, I had to rename the `con_args` field

  in `ConDeclGADT` to `con_g_args` to make it typecheck.

  A consequence of all this is that the `con_args` field is now partial, so

  using `con_args` as a top-level field selector is dangerous. (Indeed, Haddock

  was using `con_args` at the top-level, which caused it to crash at runtime

  before I noticed what was wrong!) I decided to add a disclaimer in the 9.2.1

  release notes to advertise this pitfall.

Fixes #18844. Bumps the `haddock` submodule.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/57c3db9612463426e1724816fd3f98142fec0e31">57c3db96</a></strong>

<div>

<span>by Ryan Scott</span>

<i>at 2020-10-31T02:53:55-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Make typechecker equality consider visibility in ForAllTys

Previously, `can_eq_nc'` would equate `ForAllTy`s regardless of their

`ArgFlag`, including `forall i -> i -> Type` and `forall i. i -> Type`! To fix

this, `can_eq_nc'` now uses the `sameVis` function to first check if the

`ArgFlag`s are equal modulo specificity. I have also updated `tcEqType`'s

implementation to match this behavior. For more explanation on the "modulo

specificity" part, see the new `Note [ForAllTy and typechecker equality]`

in `GHC.Tc.Solver.Canonical`.

While I was in town, I fixed some related documentation issues:

* I added `Note [Typechecker equality]` to `GHC.Tc.Utils.TcType` to describe

  what exactly distinguishes `can_eq_nc'` and `tcEqType` (which implement

  typechecker equality) from `eqType` (which implements definitional equality,

  which does not care about the `ArgFlags` of `ForAllTy`s at all).

* The User's Guide had some outdated prose on the specified/inferred

  distinction being different for types and kinds, a holdover from #15079. This

  is no longer the case on today's GHC, so I removed this prose, added some new

  prose to take its place, and added a regression test for the programs in

  #15079.

* The User's Guide had some _more_ outdated prose on inferred type variables

  not being allowed in `default` type signatures for class methods, which is no

  longer true as of the resolution of #18432.

* The related `Note [Deferred Unification]` was being referenced as

  `Note [Deferred unification]` elsewhere, which made it harder to `grep`

  for. I decided to change the name of the Note to `Deferred unification`

  for consistency with the capitalization style used for most other Notes.

Fixes #18863.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/a98593f0c7623843a787af5fb628336cb897c527">a98593f0</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:54:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Refactor numeric constant folding rules

Avoid the use of global pattern synonyms.

1) I think it's going to be helpful to implement constant folding for

   other numeric types, especially Natural which doesn't have a wrapping

   behavior. We'll have to refactor these rules even more so we'd better

   make them less cryptic.

2) It should also be slightly faster because global pattern synonyms

   matched operations for every numeric types instead of the current one:

   e.g., ":**:" pattern was matching multiplication for both Int# and

   Word# types. As we will probably want to implement constant folding

   for other numeric types (Int8#, Int16#, etc.), it is more efficient

   to only match primops for a given type as we do now.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/730ef38f467d67f4f664b2b4a5f4b236864e97b2">730ef38f</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:54:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Simplify constant-folding (#18032)

See #18032 for the details.

* Use `Lit (LitNumber _ i)` instead of `isLitValue_maybe` which does

  more work but that is not needed for constant-folding

* Don't export `GHC.Types.Literal.isLitValue_maybe`

* Kill `GHC.Types.Literal.isLitValue` which isn't used

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/d5a53c1aa6a417a466deb5951c0cc4cd94be97c0">d5a53c1a</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-31T02:55:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops.txt.pp: Move ByteArray# primops to separate file

This file will be generated.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/b4278a41a18132a981b25c59b296cdf3ba970024">b4278a41</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-31T02:55:10-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">primops: Generate ByteArray# index/read/write primops

Previously these were mostly undocumented and was ripe for potential

inconsistencies.

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/08e6993a1b956e6edccdc1cecc7250b724bf79a0">08e6993a</a></strong>

<div>

<span>by Sylvain Henry</span>

<i>at 2020-10-31T02:55:50-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move loadDecl into IfaceToCore

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/cb1f755c6fb77f140aee11fdc7b4da04dd5dcd02">cb1f755c</a></strong>

<div>

<span>by Tamar Christina</span>

<i>at 2020-10-31T09:26:56-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">winio: Fix unused variables warnings

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/eb368078204bceba51e3c80e387ce1d776762cfd">eb368078</a></strong>

<div>

<span>by Andrzej Rybczak</span>

<i>at 2020-10-31T09:27:34-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add testcase for #816

</pre>

</li>

<li>

<strong><a href="https://gitlab.haskell.org/ghc/ghc/-/commit/efa9c6f2846dddf2ac85d49ff54fb5d9f6aa53a8">efa9c6f2</a></strong>

<div>

<span>by Ben Gamari</span>

<i>at 2020-10-31T20:14:23-04:00</i>

</div>

<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">nativeGen: Deduplicate DWARF strings

As noted in #17609, we previously made no attempt to deduplicate

strings. This resulted in unnecessarily long compile times and large

object files. Fix this.

Fixes #17609.

</pre>

</li>

</ul>

<h4>18 changed files:</h4>

<ul>

<li class="file-stats">

<a href="#70f0e3f682e0543f692942cb7bafd17134d6b88b">

<span class="new-file">

+

.git-ignore-revs

</span>

</a>

</li>

<li class="file-stats">

<a href="#a5cc2925ca8258af241be7e5b0381edf30266302">

.gitignore

</a>

</li>

<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="#e3912a2eb40cf45e3dc98ea1b0275653264428e6">

<span class="new-file">

+

.gitlab/common.sh

</span>

</a>

</li>

<li class="file-stats">

<a href="#412267f7d5ed866deae5ac2ca598ff8092b826b6">

.gitlab/linters/check-cpp.py

</a>

</li>

<li class="file-stats">

<a href="#b25b374c2459de3e2aaed42163f492c8b8614385">

.gitlab/merge_request_templates/merge-request.md

</a>

</li>

<li class="file-stats">

<a href="#f656107cc03a27946448887125380c358788500e">

.gitlab/test-metrics.sh

</a>

</li>

<li class="file-stats">

<a href="#7445606fbf8f3683cd42bdc54b05d7a0bc2dfc44">

.gitmodules

</a>

</li>

<li class="file-stats">

<a href="#abe895765c4ce08c5dfbc95e5e3c5db67ff92ded">

CODEOWNERS

</a>

</li>

<li class="file-stats">

<a href="#836efb6e25a091dcb4ff8e1dbb2f0be6a5cbf14c">

Makefile

</a>

</li>

<li class="file-stats">

<a href="#8ec9a00bfd09b3190ac6b22251dbb1aa95a0579d">

README.md

</a>

</li>

<li class="file-stats">

<a href="#9ab3868b23ed5d5a6e12ef902049902556fa4009">

aclocal.m4

</a>

</li>

<li class="file-stats">

<a href="#5679d72ae7645e5e1a929ed09c3a58d0a511176d">

<span class="new-file">

+

compiler/.hlint.yaml

</span>

</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">

<span class="deleted-file">

−

compiler/GHC/Builtin/Names.hs-boot

</span>

</a>

</li>

<li class="file-stats">

<a href="#06764eb0158306b83ab1998d18316392a51838c2">

compiler/GHC/Builtin/Names/TH.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/92c7a720b306a40cb238c2eef7e1e4a74e82ffaa...efa9c6f2846dddf2ac85d49ff54fb5d9f6aa53a8">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>