artifacts: false

     - job: project-version

   script:

   rules:

     - if: $NIGHTLY

     # TODO: We could work out the --version from the project-version CI job.

     parser.add_argument('--version', required=True, type=str, help='Version of the GHC compiler')

     parser.add_argument('--date', required=True, type=str, help='Date of the compiler release')

     args = parser.parse_args()

     project = gl.projects.get(1, lazy=True)

         with open(args.metadata, 'r') as file:

             ghcup_metadata = yaml.safe_load(file)

             if  args.version in ghcup_metadata['ghcupDownloads']['GHC']:

             setNightlyTags(ghcup_metadata)

             ghcup_metadata['ghcupDownloads']['GHC'][args.version] = new_yaml

 import GHC.Types.Unique.FM

 import GHC.Types.Unique

 import GHC.Utils.Word64 (truncateWord64ToWord32)

 import Control.Arrow (first, second)

 import Data.List.NonEmpty (NonEmpty (..))

 import qualified Data.List.NonEmpty as NE

 -- TODO: Use optimization fuel

 elimCommonBlocks :: CmmGraph -> CmmGraph

   where

      env = iterate mapEmpty blocks_with_key

      -- The order of blocks doesn't matter here. While we could use

      -- revPostorder which drops unreachable blocks this is done in

      -- ContFlowOpt already which runs before this pass. So we use

      -- toBlockList since it is faster.

      blocks_with_key = [ [ (successors b, [b]) | b <- bs] | bs <- groups]

 -- Invariant: The blocks in the list are pairwise distinct

 -- (so avoid comparing them again)

 type DistinctBlocks = [CmmBlock]

 -- This is a subtle and important function

 -- See Note [Interesting dictionary arguments]

 interestingDict env (Var v)  -- See (ID3) and (ID5)

   | Just rhs <- maybeUnfoldingTemplate (idUnfolding v)

   = interestingDict env rhs

 interestingDict env arg  -- Main Plan: use exprIsConApp_maybe

        , isIPClass cls      -- See (ID5)

        -> False

        | otherwise

   | Just (_, _, data_con, _tys, args) <- exprIsConApp_maybe in_scope_env arg

   , Just cls <- tyConClass_maybe (dataConTyCon data_con)

   where

     arg_ty                  = exprType arg

     definitely_not_ip_like  = not (couldBeIPLike arg_ty)

 {- Note [Ticks on applications]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    (Remember: a constraint tuple is just a class with N superclasses and no methods.)

    See discussion on #26831.

 (ID8) Sadly, if `exprIsConApp_maybe` says Nothing, we still want to treat a

    non-trivial argument as interesting. In T19695 we have this:

 There are many different ways to build a compiler, each way is called a flavour.

 * `--flavour=FLAVOUR`: choose a build flavour. The following settings are

 In addition to the overall build flavour there are also "flavour transformers"

 which can slightly modify the build settings for a flavour. Some common flavour

 - `git submodule update --init`

 - `./configure --target=arm-linux-gnueabihf`

 - `cd hadrian`

 After that, you should have built `inplace/bin/ghc-stage1` cross compiler. We will go to the next section to validate this.

     <td>-O</td>

     <td>-debug (link)</td>

   </tr>

   <tr>

     <th>perf</td>

     <td> Yes (on supported platforms) </td>

     <td>debug<br>threaded<br>threadedDebug<br>debugDynamic<br>threadedDynamic<br>threadedDebugDynamic</td>

     <td>debug<br>threaded<br>threadedDebug<br>debugDynamic<br>threadedDynamic<br>threadedDebugDynamic</td>

 </tr>

 </table>

   build _build/stage1/lib/package.conf.d/text-1.2.3.0.conf # OR actual path

   ```

   ``` sh

   # Make

   make

   # Hadrian

   ```

   See [flavours documentation](https://gitlab.haskell.org/ghc/ghc/blob/master/hadrian/doc/flavours.md) for info on flavours.

 stack build

 # Build GHC

 # Test GHC

 cd ..

 ```

 The entire process should take about 20 minutes. Note, this will build GHC

 flag from the build command line (this will slow down the build to about an hour).

 These are currently not the

 The `stack build` and `stack exec hadrian` commands can be replaced by an

 invocation of Hadrian's Stack-based build script:

 Hadrian and/or rebuild GHC often.

 ## Prerequisites

                        , Settings.Flavours.Performance

                        , Settings.Flavours.Quick

                        , Settings.Flavours.QuickCross

                        , Settings.Flavours.Validate

                        , Settings.Flavours.Release

                        , Settings.Packages

     , Option ['o'] ["build-root"] (ReqArg readBuildRoot "BUILD_ROOT")

       "Where to store build artifacts. (Default _build)."

     , Option [] ["flavour"] (OptArg readFlavour "FLAVOUR")

     , Option [] ["freeze1"] (NoArg readFreeze1)

       "Freeze Stage1 GHC."

     , Option [] ["freeze2"] (NoArg readFreeze2)

 @foo.bar.baz = v@ or @foo.bar.baz += v@ expressions, that one can

 pass on the command line that invokes hadrian:

 or in a file at <build root>/hadrian.settings, where <build root>

 is the build root to be used for the build, which is _build by default.

 import Settings.Flavours.GhcInGhci

 import Settings.Flavours.Performance

 import Settings.Flavours.Quick

 import Settings.Flavours.QuickCross

 import Settings.Flavours.Validate

 import Settings.Flavours.Release

     , developmentFlavour Stage2, performanceFlavour

     , releaseFlavour

     , quickFlavour, quickValidateFlavour, quickDebugFlavour

     , quickCrossFlavour

     , ghcInGhciFlavour, validateFlavour, slowValidateFlavour

     ]

 flavour :: Action Flavour

 flavour = do

     flavourName <- fromMaybe userDefaultFlavour <$> cmdFlavour

     kvs <- userSetting ([] :: [KeyVal])

     let flavours = hadrianFlavours ++ userFlavours

         (settingErrs, tweak) = applySettings kvs

 # Performance test for lookups in the family application cache

 test('FamAppCachePerf',

      [ only_ways(['normal'])

      , collect_compiler_stats('bytes allocated',2)

      ],

      compile,

 test('T23429', normal, compile_and_run, ['-O'])

 test('T27071', normal, compile_and_run, ['-O -fworker-wrapper-cbv'])

 test('T27005', [], multimod_compile_and_run, ['T27005', '-O'])

 -- 5. The testsuite driver will use dyn way for TH/ghci tests even

 --    when host GHC is static.

 -- 6. TH/ghci doesn't work if stage1 is built without shared libraries

 tgtRTSLinkerOnlySupportsSharedLibs :: Target -> Bool

 tgtRTSLinkerOnlySupportsSharedLibs Target{tgtArchOs} =

   archOS_arch tgtArchOs `elem`