<!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/fix-windows
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/8584430e1d5f45fec33c783fc3bd6b781fad68de">8584430e</a></strong>
<div>
<span>by Ömer Sinan Ağacan</span>
<i>at 2019-06-19T12:00:11Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix a Note name in CmmNode

("Continuation BlockIds" is referenced in CmmProcPoint)

[skip ci]
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/9d58554f7b19c52896796e8c3b6de20c154a67b2">9d58554f</a></strong>
<div>
<span>by Ömer Sinan Ağacan</span>
<i>at 2019-06-20T02:14:26Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Properly trim IdInfos of DFunIds and PatSyns in TidyPgm

Not doing this right caused #16608. We now properly trim IdInfos of
DFunIds and PatSyns.

Some further refactoring done by SPJ.

Two regression tests T16608_1 and T16608_2 added.

Fixes #16608
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/39c758e1426c9e5b00de2207ad53bb4377c1e6a6">39c758e1</a></strong>
<div>
<span>by Roland Senn</span>
<i>at 2019-06-20T02:15:04Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix #1620: ModBreaks.modBreaks_array not initialised

After a :cd command and after setting some package flags,
GHCi unloads all loaded modules by resetting the list of targets.

This patch deletes eventually defined debugger breakpoints, before GHCi resets the target list.

The common code is factored out into the new function clearAllTargets.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/3c9b57b07fa1d4a5fa69fb77ee8e49f7a0b6ada9">3c9b57b0</a></strong>
<div>
<span>by Simon Peyton Jones</span>
<i>at 2019-06-20T02:15:39Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix two places that failed the substitution invariant

The substition invariant relies on keeping the in-scope
set in sync, and we weren't always doing so, which means that
a DEBUG compiler crashes sometimes with an assertion failure

This patch fixes a couple more cases.  Still not validate
clean (with -DEEBUG) but closer!
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/48fb3482f8cbc8a4b37161021e846105f980eed4">48fb3482</a></strong>
<div>
<span>by Simon Peyton Jones</span>
<i>at 2019-06-20T02:15:39Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Fix typechecking of partial type signatures

Partial type sigs had grown hair.  tcHsParialSigType was
doing lots of unnecessary work, and tcInstSig was cloning it
unnecessarily -- and the result didn't even work: #16728.

This patch cleans it all up, described by TcHsType
  Note [Checking parital type signatures]

I basically just deleted code... but very carefully!

Some refactoring along the way

* Distinguish more explicintly between "anonymous" wildcards "_"
  and "named" wildcards "_a".  I changed the names of a number
  of functions to make this distinction much more apparent.

The patch also revealed that the code in `TcExpr`
that implements the special typing rule for `($)` was wrong.
It called `getRuntimeRep` in a situation where where was no
particular reason to suppose that the thing had kind `TYPE r`.

This caused a crash in typecheck/should_run/T10846.

The fix was easy, and actually simplifies the code in `TcExpr`
quite a bit.  Hooray.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/3ae23992786c7ea3211ab6f13e1d61a5edfe5952">3ae23992</a></strong>
<div>
<span>by Simon Peyton Jones</span>
<i>at 2019-06-20T02:15:39Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Comments and tiny refactor

* Added Note [Quantified varaibles in partial type signatures]
  in TcRnTypes

* Kill dVarSetElemsWellScoped; it was only called in
  one function, quantifyTyVars.  I inlined it because it
  was only scopedSort . dVarSetElems

* Kill Type.tyCoVarsOfBindersWellScoped, never called.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/bff2f24ba9104275c665b6a0cf30a8dd18407392">bff2f24b</a></strong>
<div>
<span>by John Ericson</span>
<i>at 2019-06-20T02:16:16Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Move 'Platform' to ghc-boot

ghc-pkg needs to be aware of platforms so it can figure out which
subdire within the user package db to use. This is admittedly
roundabout, but maybe Cabal could use the same notion of a platform as
GHC to good affect too.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/a298b96e624155e1860ff009951cb21be43b99d4">a298b96e</a></strong>
<div>
<span>by John Ericson</span>
<i>at 2019-06-20T02:16:16Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add 'stringEncodeArch' and 'stringEncodeOS' to GHC.Platform
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/d406a16ac22e6ad02da0d2c75212614eda09d2cb">d406a16a</a></strong>
<div>
<span>by John Ericson</span>
<i>at 2019-06-20T02:16:16Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">ghc-pkg needs settings file to un-hardcode target platform

This matches GHC itself getting the target platform from there.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/aa4891a729649051f45adcef1fddbda1b0639e94">aa4891a7</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-20T02:16:51Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Fix a variety of broken links and syntax
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/fe819dd637842fb564524a7cf80612a3673ce14c">fe819dd6</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-20T02:16:51Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">users-guide: Update -Wsafe description for #16689

We no longer emit a warning when a safe module is explicitly declared as
such.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/c311277bf640a4aeb929f3080eaaf656c0e0611c">c311277b</a></strong>
<div>
<span>by Matthías Páll Gissurarson</span>
<i>at 2019-06-21T01:21:21Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">Add HoleFitPlugins and RawHoleFits

This patch adds a new kind of plugin, Hole fit plugins. These plugins
can change what candidates are considered when looking for valid hole
fits, and add hole fits of their own. The type of a plugin is relatively
simple,

```
type FitPlugin = TypedHole -> [HoleFit] -> TcM [HoleFit]
type CandPlugin = TypedHole -> [HoleFitCandidate] -> TcM [HoleFitCandidate]
data HoleFitPlugin = HoleFitPlugin { candPlugin :: CandPlugin
                                   , fitPlugin :: FitPlugin }

data TypedHole = TyH { tyHRelevantCts :: Cts
                       -- ^ Any relevant Cts to the hole
                     , tyHImplics :: [Implication]
                       -- ^ The nested implications of the hole with the
                       --   innermost implication first.
                     , tyHCt :: Maybe Ct
                       -- ^ The hole constraint itself, if available.
                     }

This allows users and plugin writers to interact with the candidates and
fits as they wish, even going as far as to allow them to reimplement the
current functionality (since `TypedHole` contains all the relevant
information).

As an example, consider the following plugin:

```
module HolePlugin where

import GhcPlugins

import TcHoleErrors

import Data.List (intersect, stripPrefix)
import RdrName (importSpecModule)

import TcRnTypes

import System.Process

plugin :: Plugin
plugin = defaultPlugin { holeFitPlugin = hfp, pluginRecompile = purePlugin }

hfp :: [CommandLineOption] -> Maybe HoleFitPluginR
hfp opts = Just (fromPureHFPlugin $ HoleFitPlugin (candP opts) (fp opts))

toFilter :: Maybe String -> Maybe String
toFilter = flip (>>=) (stripPrefix "_module_")

replace :: Eq a => a -> a -> [a] -> [a]
replace match repl str = replace' [] str
  where
    replace' sofar (x:xs) | x == match = replace' (repl:sofar) xs
    replace' sofar (x:xs) = replace' (x:sofar) xs
    replace' sofar [] = reverse sofar

-- | This candidate plugin filters the candidates by module,
--   using the name of the hole as module to search in
candP :: [CommandLineOption] -> CandPlugin
candP _ hole cands =
  do let he = case tyHCt hole of
                Just (CHoleCan _ h) -> Just (occNameString $ holeOcc h)
                _ -> Nothing
     case toFilter he of
        Just undscModName -> do let replaced = replace '_' '.' undscModName
                                let res = filter (greNotInOpts [replaced]) cands
                                return $ res
        _ -> return cands
  where greNotInOpts opts (GreHFCand gre)  = not $ null $ intersect (inScopeVia gre) opts
        greNotInOpts _ _ = True
        inScopeVia = map (moduleNameString . importSpecModule) . gre_imp

-- Yes, it's pretty hacky, but it is just an example :)
searchHoogle :: String -> IO [String]
searchHoogle ty = lines <$> (readProcess "hoogle" [(show ty)] [])

fp :: [CommandLineOption] -> FitPlugin
fp ("hoogle":[]) hole hfs =
    do dflags <- getDynFlags
       let tyString = showSDoc dflags . ppr . ctPred <$> tyHCt hole
       res <- case tyString of
                Just ty -> liftIO $ searchHoogle ty
                _ -> return []
       return $ (take 2 $ map (RawHoleFit . text . ("Hoogle says: " ++)) res) ++ hfs
fp _ _ hfs = return hfs

```

with this plugin available, you can compile the following file

```
{-# OPTIONS -fplugin=HolePlugin -fplugin-opt=HolePlugin:hoogle #-}
module Main where

import Prelude hiding (head, last)

import Data.List (head, last)

t :: [Int] -> Int
t = _module_Prelude

g :: [Int] -> Int
g = _module_Data_List

main :: IO ()
main = print $ t [1,2,3]
```

and get the following output:

```
Main.hs:14:5: error:
    • Found hole: _module_Prelude :: [Int] -> Int
      Or perhaps ‘_module_Prelude’ is mis-spelled, or not in scope
    • In the expression: _module_Prelude
      In an equation for ‘t’: t = _module_Prelude
    • Relevant bindings include
        t :: [Int] -> Int (bound at Main.hs:14:1)
      Valid hole fits include
        Hoogle says: GHC.List length :: [a] -> Int
        Hoogle says: GHC.OldList length :: [a] -> Int
        t :: [Int] -> Int (bound at Main.hs:14:1)
        g :: [Int] -> Int (bound at Main.hs:17:1)
        length :: forall (t :: * -> *) a. Foldable t => t a -> Int
          with length @[] @Int
          (imported from ‘Prelude’ at Main.hs:5:1-34
           (and originally defined in ‘Data.Foldable’))
        maximum :: forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
          with maximum @[] @Int
          (imported from ‘Prelude’ at Main.hs:5:1-34
           (and originally defined in ‘Data.Foldable’))
        (Some hole fits suppressed; use -fmax-valid-hole-fits=N or -fno-max-valid-hole-fits)
   |
14 | t = _module_Prelude
   |     ^^^^^^^^^^^^^^^

Main.hs:17:5: error:
    • Found hole: _module_Data_List :: [Int] -> Int
      Or perhaps ‘_module_Data_List’ is mis-spelled, or not in scope
    • In the expression: _module_Data_List
      In an equation for ‘g’: g = _module_Data_List
    • Relevant bindings include
        g :: [Int] -> Int (bound at Main.hs:17:1)
      Valid hole fits include
        Hoogle says: GHC.List length :: [a] -> Int
        Hoogle says: GHC.OldList length :: [a] -> Int
        g :: [Int] -> Int (bound at Main.hs:17:1)
        head :: forall a. [a] -> a
          with head @Int
          (imported from ‘Data.List’ at Main.hs:7:19-22
           (and originally defined in ‘GHC.List’))
        last :: forall a. [a] -> a
          with last @Int
          (imported from ‘Data.List’ at Main.hs:7:25-28
           (and originally defined in ‘GHC.List’))
   |
17 | g = _module_Data_List

```

This relatively simple plugin has two functions, as an example of what
is possible to do with hole fit plugins. The candidate plugin starts by
filtering the candidates considered by module, indicated by the name of
the hole (`_module_Data_List`). The second function is in the fit
plugin, where the plugin invokes a local hoogle instance to search by
the type of the hole.

By adding the `RawHoleFit` type, we can also allow these completely free
suggestions, used in the plugin above to display fits found by Hoogle.

Additionally, the `HoleFitPluginR` wrapper can be used for plugins to
maintain state between invocations, which can be used to speed up
invocation of plugins that have expensive initialization.

```
-- | HoleFitPluginR adds a TcRef to hole fit plugins so that plugins can
-- track internal state. Note the existential quantification, ensuring that
-- the state cannot be modified from outside the plugin.
data HoleFitPluginR = forall s. HoleFitPluginR
  { hfPluginInit :: TcM (TcRef s)
    -- ^ Initializes the TcRef to be passed to the plugin
  , hfPluginRun :: TcRef s -> HoleFitPlugin
    -- ^ The function defining the plugin itself
  , hfPluginStop :: TcRef s -> TcM ()
    -- ^ Cleanup of state, guaranteed to be called even on error
  }
```

Of course, the syntax here is up for debate, but hole fit plugins allow
us to experiment relatively easily with ways to interact with
typed-holes without having to dig deep into GHC.

Reviewers: bgamari

Subscribers: rwbarton, carter

Differential Revision: https://phabricator.haskell.org/D5373
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/2485c08aeecd9664bca7812e69e59b85ce16c079">2485c08a</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Skip dynamicToo006 when dynamic linking is not available

This was previously failling on Windows.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/aa5164313aa86941bf15722936824dfbf556a911">aa516431</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T3372 as fragile on Windows

On Windows we must lock package databases even when opening for
read-only access. This means that concurrent GHC sessions are very
likely to fail with file lock contention.

See #16773.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/2eedb120a6fae214ca5b55658939a359bc55d19a">2eedb120</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Add stderr output for UnsafeInfered02 on Windows

This test uses TemplateHaskell causing GHC to build dynamic objects on
platforms where dynamic linking is available. However, Windows doesn't support
dynamic linking. Consequently the test would fail on Windows with:

```patch
--- safeHaskell/safeInfered/UnsafeInfered02.run/UnsafeInfered02.stderr.normalised       2019-06-04 15:10:10.521594200 +0000
+++ safeHaskell/safeInfered/UnsafeInfered02.run/UnsafeInfered02.comp.stderr.normalised  2019-06-04 15:10:10.523546200 +0000
@@ -1,5 +1,5 @@
-[1 of 2] Compiling UnsafeInfered02_A ( UnsafeInfered02_A.hs, UnsafeInfered02_A.o, UnsafeInfered02_A.dyn_o )
-[2 of 2] Compiling UnsafeInfered02  ( UnsafeInfered02.hs, UnsafeInfered02.o, UnsafeInfered02.dyn_o )
+[1 of 2] Compiling UnsafeInfered02_A ( UnsafeInfered02_A.hs, UnsafeInfered02_A.o )
+[2 of 2] Compiling UnsafeInfered02  ( UnsafeInfered02.hs, UnsafeInfered02.o )

 UnsafeInfered02.hs:4:1:
     UnsafeInfered02_A: Can't be safely imported!
```

The other approach I considered for this issue is to pass `-v0` to GHC.
However, I felt we should probably do this consistently for all of the tests in
this directory and this would take more time than I currently have.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/3967d13a2037d65d4f00fc43076b53339b475876">3967d13a</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark OldModLocation as broken on Windows

Strangely the path it emits contains duplicate path delimiters (#16772),
```patch
--- ghc-api/downsweep/OldModLocation.run/OldModLocation.stderr.normalised       2019-06-04 14:40:26.326075000 +0000
+++ ghc-api/downsweep/OldModLocation.run/OldModLocation.run.stderr.normalised   2019-06-04 14:40:26.328029200 +0000
@@ -1 +1 @@
-[Just "A.hs",Just "mydir/B.hs"]
+[Just "A.hs",Just "mydir//B.hs"]
```
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/31f2ea6899041974c601ca368b9c2af5e8de125b">31f2ea68</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T7170 as broken on Windows

Due to #16801.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/7bd1c3e15f83c04447bc2ec41bbc36c9c1b7fe0d">7bd1c3e1</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T7702 as broken on Windows

Due to #16799.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/84900724d59f092a6eebe2834c1c5a62186e430e">84900724</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T15633a and T15633b as fragile on Windows

As noted in #16813, these tests seem to be fragile on Windows.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/49fff41d0385ac1ad80a1a8b2ae33e765e89a088">49fff41d</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-21T17:32:34Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">linker: Disable code unloading

As noted in #16841, there are currently a variety of bugs in the
unloading logic. These only affect Windows since code unloading is
disabled on Linux, where we build with `GhcDynamic=YES` by default.

In the interest of getting the tree green on Windows disable code
unloading until the issues are resolved.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/e0595d22ce5bc19699079abdb47377b5707cdbbc">e0595d22</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-22T13:36:53Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">testsuite: Mark T16608_* as fragile on Darwin

As noted in #16855.
</pre>
</li>
<li>
<strong><a href="https://gitlab.haskell.org/ghc/ghc/commit/79c51112ddc812b1fe1ab07ef3c3f103a331eb6f">79c51112</a></strong>
<div>
<span>by Ben Gamari</span>
<i>at 2019-06-22T13:51:56Z</i>
</div>
<pre class="commit-message" style="white-space: pre-wrap; margin: 0;">gitlab-ci: Don't allow Windows make job to fail

While linking is still slow (#16084) all of the correctness issues which were
preventing us from being able to enforce testsuite-green on Windows are now
resolved.
</pre>
</li>
</ul>
<h4>30 changed files:</h4>
<ul>
<li class="file-stats">
<a href="#587d266bb27a4dc3022bbed44dfa19849df3044c">
.gitlab-ci.yml
</a>
</li>
<li class="file-stats">
<a href="#bd4216a09ad2640db4a06e7b5a593a1a94e884fa">
compiler/basicTypes/Literal.hs
</a>
</li>
<li class="file-stats">
<a href="#4da676ff520e0439237349c56dc60033a512f7fd">
compiler/basicTypes/PatSyn.hs
</a>
</li>
<li class="file-stats">
<a href="#db6936871693fa68c3fdcbd692eb7dcffc3a9372">
compiler/cmm/CLabel.hs
</a>
</li>
<li class="file-stats">
<a href="#1e0323ce1d793f84bf5d205379bbf732777f1826">
compiler/cmm/CmmBuildInfoTables.hs
</a>
</li>
<li class="file-stats">
<a href="#e113fc0aba1ae306436787b3a33f8bb25fd513a9">
compiler/cmm/CmmCallConv.hs
</a>
</li>
<li class="file-stats">
<a href="#8131b096a76ab4cb878cbed760d2810c8d6e8d75">
compiler/cmm/CmmInfo.hs
</a>
</li>
<li class="file-stats">
<a href="#60e57e1a715d0190e7ad5f748df9ed2d25d9b4eb">
compiler/cmm/CmmNode.hs
</a>
</li>
<li class="file-stats">
<a href="#ae8f0bda9e027203c3eee3a49c3a91a008d1fa07">
compiler/cmm/CmmOpt.hs
</a>
</li>
<li class="file-stats">
<a href="#6ef05b1b6c1d8310a12b77b1b849f9dad563141c">
compiler/cmm/CmmParse.y
</a>
</li>
<li class="file-stats">
<a href="#ae6e3e0df83ed7fe72dadc7efc769ec53aa3b5c0">
compiler/cmm/CmmPipeline.hs
</a>
</li>
<li class="file-stats">
<a href="#3a808fa515a871c8ab2ca9def5fdad093c6b1eee">
compiler/cmm/CmmProcPoint.hs
</a>
</li>
<li class="file-stats">
<a href="#afcc1828607f9b06cc137d329fec1a748d150f7f">
compiler/cmm/CmmSink.hs
</a>
</li>
<li class="file-stats">
<a href="#61470c7221010080ec380a45874259d0ed73da4a">
compiler/cmm/PprC.hs
</a>
</li>
<li class="file-stats">
<a href="#3b6b3c52b0ce37a273ebf221d41ba7a31c47da22">
compiler/cmm/SMRep.hs
</a>
</li>
<li class="file-stats">
<a href="#8334ca5418bb3db766d4620ebc6694a574c9c757">
compiler/codeGen/CodeGen/Platform.hs
</a>
</li>
<li class="file-stats">
<a href="#fffa4df16ae22e70af0a401bb89898f1da114c6b">
compiler/codeGen/StgCmmCon.hs
</a>
</li>
<li class="file-stats">
<a href="#731b07c16b2f4bb31dd7defa4ceef54e74473cc7">
compiler/codeGen/StgCmmPrim.hs
</a>
</li>
<li class="file-stats">
<a href="#f50439b73583d5fc97ab8917b6fc66f6188a1e62">
compiler/coreSyn/CorePrep.hs
</a>
</li>
<li class="file-stats">
<a href="#01d9cedeb185204af1d64df9cd22e7be05edb0d9">
compiler/coreSyn/CoreTidy.hs
</a>
</li>
<li class="file-stats">
<a href="#63dbfc2cf83281f1f0f33b2eced77c01f00557f0">
compiler/coreSyn/CoreUtils.hs
</a>
</li>
<li class="file-stats">
<a href="#cf5b233b6ec5c0a6951d1018fee507d2d2d71391">
compiler/deSugar/DsForeign.hs
</a>
</li>
<li class="file-stats">
<a href="#0f33fd88c617246c7f89c4477d2d1d24f942df23">
compiler/ghc.cabal.in
</a>
</li>
<li class="file-stats">
<a href="#fd3bbb2f991fadcc57d80b64e3152d27b0a2b6f6">
compiler/ghci/ByteCodeAsm.hs
</a>
</li>
<li class="file-stats">
<a href="#95e1315fd78f0f670f8d66e1c0786eee695a7666">
compiler/ghci/ByteCodeGen.hs
</a>
</li>
<li class="file-stats">
<a href="#47f4bea1d308dee249030e6063d92071b5aac240">
compiler/ghci/Linker.hs
</a>
</li>
<li class="file-stats">
<a href="#ed625742c0235606b8fbc13ddf9b161f5fb40f27">
compiler/hieFile/HieBin.hs
</a>
</li>
<li class="file-stats">
<a href="#bd128e1d11b59e2626269e806a4b49fc751a0f9d">
compiler/iface/BinIface.hs
</a>
</li>
<li class="file-stats">
<a href="#cacd8cbc59c36ab8a39258a3a1dd6c44ad547d49">
compiler/llvmGen/LlvmCodeGen/Base.hs
</a>
</li>
<li class="file-stats">
<a href="#d466b592cd08fa40441c89d4d2d4c15618d15465">
compiler/llvmGen/LlvmCodeGen/CodeGen.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/07b9fd09318141be5a5c0038c1acdf8178b84f02...79c51112ddc812b1fe1ab07ef3c3f103a331eb6f">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>