- . .gitlab/ci.sh setup

     - . .gitlab/ci.sh configure

     - hadrian/build-stack --version

 ####################################

 # Testing reinstallable ghc codepath

   setup) setup && cleanup_submodules ;;

   configure) time_it "configure" configure ;;

   build_hadrian) time_it "build" build_hadrian ;;

   test_hadrian)

     fetch_perf_notes

     res=0

 Note [How tuples work]

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

 * There are three families of tuple TyCons and corresponding

     data TupleSort = BoxedTuple | UnboxedTuple | ConstraintTuple

 * All three families are AlgTyCons, whose AlgTyConRhs is TupleTyCon

       stores them in the context field of types like HsQualTy.

 * In quite a lot of places things are restricted just to

   E.g. tupleTyCon has a Boxity argument

 * When looking up an OccName in the original-name cache

 GHC has severals types that represent various aspects of data format.

 These include:

    pipeline. This is a pair of a CmmCat and a Width.

  * 'Format.Format': The data format representation used by much of the backend.

 -}

 -- It looks very like the old MachRep, but it's now of purely local

 import GHC.Types.Unique.Set

 import GHC.Types.SrcLoc (unLoc)

 import GHC.Utils.Outputable

 import GHC.Hs.Extension (GhcPass (..), OutputableBndrId)

 import Language.Haskell.Syntax.Extension (Anno, LIdP, IdP,

                                           noExtField, NoExtField, DataConCantHappen,

 -- Boolean formula type and smart constructors

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

 type instance XBFVar           (GhcPass _) = NoExtField

 type instance XBFAnd           (GhcPass _) = NoExtField

 type instance XBFOr            (GhcPass _) = NoExtField

 type instance XXBooleanFormula (GhcPass _) = DataConCantHappen

 instance BooleanFormulaDefault (GhcPass p) where

 The rest of this note will document exactly how the first pass generates the map from labels to

 estimated source positions. The algorithms are different depending on whether tables-next-to-code

 (containing a `SourceNote`) that is near what we estimate to be the label of a return stack frame.

 With tables-next-to-code

 Please refer to the paper "Hoopl: A Modular, Reusable Library for Dataflow Analysis and Transformation"

 for a detailed explanation.

 (`CmmNode O C`, `O` means open, `C` closed). In other words, they are always at the end of a block.

 So, given a `CmmGraph`:

     beginning).

     found to it's payload as an `IpeSourceLocation`. (There are other `Tickish` constructors like

     `ProfNote` or `HpcTick`, these are ignored.)

               `ext2Q` located

               `extQ` srcSpanAnnA

               `extQ` srcSpanAnnN

       where generic :: Data a => a -> SDoc

             generic t = parens $ text (showConstr (toConstr t))

             srcSpanAnnN :: EpAnn NameAnn -> SDoc

             srcSpanAnnN = locatedAnn'' (text "SrcSpanAnnN")

             locatedAnn'' :: forall a. (Typeable a, Data a)

               => SDoc -> EpAnn a -> SDoc

             locatedAnn'' tag ss = parens $

   toHie (PendingRnSplice _ e) = toHie e

 instance (HiePass p, Data (IdGhcP p))

     toHie (L span form) =  concatM $ makeNode form (locA span) : case form of

       Var _ a ->

         [ toHie $ C Use a

       fromIfaceBooleanFormula (IfVar nm   ) = Var    noExtField $ noLocA . mkUnboundName . mkVarOccFS . ifLclNameFS $ nm

       fromIfaceBooleanFormula (IfAnd bfs  ) = And    noExtField $ map (noLocA . fromIfaceBooleanFormula) bfs

       fromIfaceBooleanFormula (IfOr bfs   ) = Or     noExtField $ map (noLocA . fromIfaceBooleanFormula) bfs

       -- See Note [Suppressing binder signatures] in GHC.Iface.Type

 (SF4) The desugarer replaces a nested expression (static e) with a top-level

   binding for an application of the function 'makeStatic' (defined in module

    s = /\abc. makeStatic location e

    f x = ...(fromStaticPtr s)...

 import GHC.Types.TyThing

 import GHC.Types.Error

 import GHC.Fingerprint

    tc_boolean_formula :: IfaceBooleanFormula -> IfL (BooleanFormula GhcRn)

    tc_boolean_formula (IfAnd ibfs  ) = BF.And    NoExtField . map noLocA <$> traverse tc_boolean_formula ibfs

    tc_boolean_formula (IfOr ibfs   ) = BF.Or     NoExtField . map noLocA <$> traverse tc_boolean_formula ibfs

    tc_boolean_formula (IfVar nm    ) = BF.Var    NoExtField .     noLocA <$> (lookupIfaceTop . mkVarOccFS . ifLclNameFS $ nm)

    mk_sc_doc pred = text "Superclass" <+> ppr pred

 name_boolformula :: { LBooleanFormula GhcPs }

         : name_boolformula_and      { $1 }

         | name_boolformula_and '|' name_boolformula

                                  ; return (sLLa $1 $> (Or noExtField [h,$3])) } }

 name_boolformula_and :: { LBooleanFormula GhcPs }

 name_boolformula_and_list :: { NonEmpty (LBooleanFormula GhcPs) }

         : name_boolformula_atom                               { NE.singleton $1 }

         | name_boolformula_atom ',' name_boolformula_and_list

                   ; return (h NE.<| $3) } }

 name_boolformula_atom :: { LBooleanFormula GhcPs }

         | name_var                  { sL1a $1 (Var noExtField $1) }

 namelist :: { Located [LocatedN RdrName] }

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

 -- Mostly use to add AnnComma, special case it to NOP if adding a zero-width annotation

 addTrailingCommaN :: MonadP m => LocatedN a -> SrcSpan -> m (LocatedN a)

 addTrailingCommaN (L anns a) span = do

   -- ** Annotations in 'GenLocated'

   LocatedA, LocatedN, LocatedAn,

   SrcSpanAnnA, SrcSpanAnnN,

   -- ** Annotation data types used in 'GenLocated'

   AnnList(..), AnnListBrackets(..),

   AnnParen(..),

   AnnCType(..),AnnWarningTxt(..),AnnOverlap(..),AnnAnnDecl(..),AnnPragSCC(..),

   NameAnn(..), NameAdornment(..),

   NoEpAnns(..),

   -- ** Trailing annotations in lists

   TrailingAnn(..), ta_location,

   addTrailingAnnToA, addTrailingCommaToN,

   noTrailingN,

   -- ** Utilities for converting between different 'GenLocated' when

 type LocatedA = GenLocated SrcSpanAnnA

 type LocatedN = GenLocated SrcSpanAnnN

 -- | Annotation for items appearing in a list. They can have one or

 -- more trailing punctuations items, such as commas or semicolons.

 type SrcSpanAnnA = EpAnn [TrailingAnn]

 -- on the context, such as backticks.

 type SrcSpanAnnN = EpAnn NameAnn

 -- | General representation of a 'GenLocated' type carrying a

 -- parameterised annotation type.

 type LocatedAn an = GenLocated (EpAnn an)

   | AnnParensHash   (EpToken "(#") (EpToken "#)") -- ^ '(#', '#)'

   deriving Data

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

 -- Annotations for names

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

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

 -- | Helper function used in the parser to add a 'TrailingAnn' items

 -- to an existing annotation.

 addTrailingAnnToA :: TrailingAnn -> EpAnnComments

 instance NoAnn NoEpAnns where

   noAnn = NoEpAnns

 instance NoAnn AnnList where

   noAnn = AnnList Nothing ListNone noAnn

   - It is only called when applying an instance decl,

     in GHC.Tc.Solver.Dict.tryInstances

     used to solve the constraint.  In particular

       * LocalInstance identifies quantified constraints

       * BuiltinEqInstance identifies the strange built-in

     eg a wanted cannot rewrite a given)

   * CEqCan equalities: see Note [inert_eqs: the inert equalities]

 Note [inert_eqs: the inert equalities]

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

 constructor wrappers].

 For further reading, see:

   * Note [Lone variables] in GHC.Core.Unfold

   * Note [exprIsConApp_maybe on data constructors with wrappers]

     in GHC.Core.SimpleOpt

 VarBndr is polymorphic in both var and visibility fields.

 Currently there are nine different uses of 'VarBndr':

   Binder of a forall-type; see ForAllTy in GHC.Core.TyCo.Rep

   Subset of ForAllTyBinder when we are sure the binder is a TyVar

   Specialised form of TyVarBinder, when ForAllTyFlag = Invisible s

   See GHC.Core.Type.splitForAllInvisTVBinders

   Specialised form of TyVarBinder, when ForAllTyFlag = Required

   See GHC.Core.Type.splitForAllReqTVBinders

   This one is barely used

   Binders of a TyCon; see TyCon in GHC.Core.TyCon

 -}

 data VarBndr var argf = Bndr var argf

                                    ('metric', MetricName),

                                    ('value', float)])

 # The type of exceptions which are thrown when computing the current stat value

 # fails.

  else:

         return get_allowed_perf_changes()

 # Get the baseline of a test at a given commit. This is the expected value

 # *before* the commit is applied (i.e. on the parent commit).

 #                      instead when looking for ci results)

 # metric: str - test metric

 # way: str - test way

 #          BaselineSearchDepth commits and since the last expected change

 #          (ignoring any expected change in the given commit).

 def baseline_metric(commit: GitHash,

                     metric: MetricName,

                     way: WayName,

                     baseline_ref: Optional[GitRef]

     # For performance reasons (in order to avoid calling commit_hash), we assert

     # commit is already a commit hash.

     assert is_commit_hash(commit)

     # Searches through previous commits trying local then ci for each commit in.

     def find_baseline(namespace: NoteNamespace,

                       test_env: TestEnv

         if baseline_commit is not None:

         for depth, current_commit in list(enumerate(commit_hashes)):

             if current_commit == commit: continue

             # Check for a metric on this commit.

             current_metric = get_commit_metric(namespace, current_commit, test_env, name, metric, way)

             if current_metric is not None:

             # Stop if there is an expected change at this commit. In that case

             # metrics on ancestor commits will not be a valid baseline.

     # Test environment to use when comparing against CI namespace

     ci_test_env = best_fit_ci_test_env()

     if baseline is None and ci_test_env is not None:

         baseline = find_baseline(CiNamespace, ci_test_env)

     result = get_commit_metric(gitNoteRef, commit, test_env, name, metric, way)

     if result is None:

         return None

 # gitNoteRef: git notes ref space e.g. "perf" or "ci/perf"

 # ref: git commit

 # test_env: test environment

 # name: test name

 # metric: test metric

 # way: test way

 def get_commit_metric(gitNoteRef,

                       ref: Union[GitRef, GitHash],

                       test_env: TestEnv,

                       name: TestName,

                       metric: MetricName,

                       way: WayName

     global _commit_metric_cache

     assert test_env != None

     commit = commit_hash(ref)

         return _commit_metric_cache[cacheKeyA].get(cacheKeyB)

     # Cache miss.

     # Note that the git note may contain data for other tests. All tests'

     allCommitMetrics = get_perf_stats(ref, gitNoteRef)

     # Collect recorded values by cacheKeyB.

         currentValues = values_by_cache_key_b.setdefault(currentCacheKey, [])

         currentValues.append(float(perfStat.value))

     for currentCacheKey, currentValues in values_by_cache_key_b.items():

 def check_stats_change(actual: PerfStat,

                        acceptance_window: MetricAcceptanceWindow,

                        allowed_perf_changes: Dict[TestName, List[AllowedPerfChange]] = {},

                        force_print = False

     Parameters:

     actual: the PerfStat with actual value

     acceptance_window: allowed deviation of the actual value from the expected

         value.

     allowed_perf_changes: allowed changes in stats. This is a dictionary as

                 ' baseline @ %s' % baseline.commit

         print(actual.metric, error + ':')

         dev = 100.0 if expected_val == 0 else round(((float(actual.value) * 100) / int(expected_val)) - 100, 1)

         change_line = (f'{actual.metric} {change.value} from {baseline.perfStat.test_env} '

                        f'baseline @ {baseline.commit[:7]}: {expected_val} -> {actual.value} '

         result = failBecause('stat ' + change_line, tag='stat')

     if not change_allowed or force_print:

             print(descr, str(val).rjust(length), extra)

         display('    Expected    ' + full_name + ' ' + actual.metric + ':', expected_val, acceptance_window.describe())

         display('    Lower bound ' + full_name + ' ' + actual.metric + ':', lowerBound, '')

         display('    Upper bound ' + full_name + ' ' + actual.metric + ':', upperBound, '')

         display('    Actual      ' + full_name + ' ' + actual.metric + ':', actual.value, '')

     # HEAD~2           21234                 21234

     # HEAD~3           20000                 20000

     def strMetric(x):

     # Data is in column major format, so transpose and pass to print_table.

     T = TypeVar('T')

     def transpose(xss: List[List[T]]) -> List[List[T]]:

 from my_typing import *

 from pathlib import Path

 from datetime import datetime

 # -----------------------------------------------------------------------------

 PerfMetric = NamedTuple('PerfMetric',

                         [('change', MetricChange),

                          ('stat', PerfStat),

 class TestRun:

    def __init__(self) -> None:

   trailing _ = []

   setTrailing a _ = a

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

 fromAnn' :: (HasEntry a) => a -> Entry

   exact (BF.And e ls) = do

     ls' <- mapM markAnnotated ls

     return (BF.And e ls')

     x' <- markAnnotated x

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

         stmts' <- markAnnotated stmts

         return stmts'

 instance ExactPrint [Located HsDocStringChunk] where

   getAnnotationEntry _ = NoEntryVal

   setAnnotationAnchor a _ _ _ = a

 type instance Anno (FamilyResultSig DocNameI) = EpAnn NoEpAnns

 type instance Anno (HsOuterTyVarBndrs Specificity DocNameI) = SrcSpanAnnA

 type instance Anno (HsSigType DocNameI) = SrcSpanAnnA

 type instance Anno (OverlapMode DocNameI) = SrcSpanAnnA

 type instance Anno (CType DocNameI) = SrcSpanAnnA

 type instance Anno (Header DocNameI) = SrcSpanAnnA

 type instance XBFVar           DocNameI = NoExtField

 type instance XBFAnd           DocNameI = NoExtField

 type instance XBFOr            DocNameI = NoExtField

 type instance XXBooleanFormula DocNameI = DataConCantHappen

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