setup) setup && cleanup_submodules ;;

   configure) time_it "configure" configure ;;

   build_hadrian) time_it "build" build_hadrian ;;

   test_hadrian)

     fetch_perf_notes

     res=0

 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

               `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

 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

                                    ('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

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