- . .gitlab/ci.sh setup

     - . .gitlab/ci.sh configure

     - hadrian/build-stack --version

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

 # Testing reinstallable ghc codepath

 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.SrcLoc

 import GHC.Types.Var.Set

 import GHC.Utils.Outputable

 import Language.Haskell.Syntax.BooleanFormula ( BooleanFormula, mkTrue )

 import qualified Data.Data as Data

 toIfaceBooleanFormula :: BF.BooleanFormula GhcRn -> IfaceBooleanFormula

 toIfaceBooleanFormula = go

   where

 {-

 ************************************************************************

 import GHC.Utils.Outputable

 import GHC.Parser.Annotation ( SrcSpanAnnBF )

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

 import Language.Haskell.Syntax.BooleanFormula

 type instance Anno (BooleanFormula (GhcPass p)) = SrcSpanAnnBF

 -- if we had Functor/Traversable (LbooleanFormula p) we could use that

 -- as a constraint and we wouldn't need to specialize to just GhcPass p,

 -- but becuase LBooleanFormula is a type synonym such a constraint is

       -> BooleanFormula (GhcPass p) -> BooleanFormula (GhcPass p')

 bfMap f = go

   where

 bfTraverse  :: Applicative f

             => (LIdP (GhcPass p) -> f (LIdP (GhcPass p')))

             -> f (BooleanFormula (GhcPass p'))

 bfTraverse f = go

   where

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

 isFalse :: BooleanFormula (GhcPass p) -> Bool

 isFalse _ = False

 isTrue :: BooleanFormula (GhcPass p) -> Bool

 isTrue _ = False

 eval :: (LIdP (GhcPass p) -> Bool) -> BooleanFormula (GhcPass p) -> Bool

 -- Simplify a boolean formula.

 -- The argument function should give the truth of the atoms, or Nothing if undecided.

           => (LIdP (GhcPass p) ->  Maybe Bool)

           -> BooleanFormula (GhcPass p)

           -> BooleanFormula (GhcPass p)

   Just b  -> mkBool b

 -- Test if a boolean formula is satisfied when the given values are assigned to the atoms

 -- if it is, returns Nothing

 -- If the boolean formula holds, does that mean that the given atom is always true?

 impliesAtom :: Eq (IdP (GhcPass p)) => BooleanFormula (GhcPass p) -> LIdP (GhcPass p) -> Bool

 implies :: (Uniquable (IdP (GhcPass p))) => BooleanFormula (GhcPass p) -> BooleanFormula (GhcPass p) -> Bool

 implies e1 e2 = go (Clause emptyUniqSet [e1]) (Clause emptyUniqSet [e2])

     go :: Uniquable (IdP (GhcPass p)) => Clause (GhcPass p) -> Clause (GhcPass p) -> Bool

     go l@Clause{ clauseExprs = hyp:hyps } r =

         case hyp of

     go l r@Clause{ clauseExprs = con:cons } =

         case con of

     go _ _ = False

 -- A small sequent calculus proof engine.

                     -> Rational -> BooleanFormula (GhcPass p) -> SDoc

 pprBooleanFormula' pprVar pprAnd pprOr = go

   where

 -- Pretty print in source syntax, "a | b | c,d,e"

 pprBooleanFormula :: (Rational -> LIdP (GhcPass p) -> SDoc)

 pprBooleanFormulaNormal :: OutputableBndrId p => BooleanFormula (GhcPass p) -> SDoc

 pprBooleanFormulaNormal = go

   where

     -- * Query

     , null

     , size

     , compareSize

     , member

     , notMember

     go acc (Tip _ _) = 1 + acc

     go acc Nil = acc

 -- | \(O(\min(n,c))\). Compare the number of entries in the map to an @Int@.

 --

 -- @compareSize m c@ returns the same result as @compare ('size' m) c@ but is

     -- ** Size

     , WM.null

     , size

     , compareSize

     -- * Combine

     -- ** Size

     , null

     , size

     , compareSize

     -- * Combine

     -- ** Size

     , null

     , size

     , compareSize

     -- * Combine

   , spanAntitone

   , restrictKeys

   , size

   , compareSize

   , split

   , splitLookup

 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.)

 instance (HiePass p, Data (IdGhcP p))

   => ToHie (GenLocated SrcSpanAnnBF (BooleanFormula (GhcPass p))) where

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

         [ toHie $ C Use a

         ]

         [ toHie forms

         ]

         [ toHie forms

         ]

         [ toHie f

         ]

 import GHC.Data.BooleanFormula (pprBooleanFormula, isTrue)

 import Language.Haskell.Syntax.BooleanFormula(BooleanFormula(..))

 import Language.Haskell.Syntax.Text

 import Control.Monad

       fromIfaceBooleanFormula :: IfaceBooleanFormula -> BooleanFormula GhcRn

       -- `mkUnboundName` here is fine because the Name generated is only used for pretty printing and nothing else.

       -- 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)...

           return (ATI tc mb_def)

    tc_boolean_formula :: IfaceBooleanFormula -> IfL (BooleanFormula GhcRn)

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

    mk_at_doc tc = text "Associated type" <+> ppr tc

         : name_boolformula_and      { $1 }

         | name_boolformula_and '|' name_boolformula

                            {% do { h <- addTrailingVbarBF $1 (epTok $2)

 name_boolformula_and :: { LBooleanFormula GhcPs }

         : name_boolformula_and_list

 name_boolformula_and_list :: { NonEmpty (LBooleanFormula GhcPs) }

         : name_boolformula_atom                               { NE.singleton $1 }

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

 name_boolformula_atom :: { LBooleanFormula GhcPs }

                                             (AnnBooleanFormula (epTok $1) (epTok $3) [])  }

 namelist :: { Located [LocatedN RdrName] }

 namelist : name_var              { sL1 $1 [$1] }

   - 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]

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

   where

     -- By default require all methods without a default implementation

     defMindef :: ClassMinimalDef

                       | (name, _, Nothing) <- op_info ]

 instantiateMethod :: Class -> TcId -> [TcType] -> TcType

 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

 {-# INLINE foldUDFM #-}

 -- Specialises k and z into M.foldr on the small-map path.

 foldUDFM k z (UDFM m ub)

 fold_udfm :: (elt -> a -> a) -> a -> M.Word64Map (TaggedVal elt) -> Int -> a

 {-# NOINLINE fold_udfm #-}

 {-# INLINE eltsUDFM #-}  -- so the small case is a good producer

                          -- This matters for T13719.

 eltsUDFM (UDFM m ub)

 elts_udfm :: M.Word64Map (TaggedVal elt) -> Int -> [elt]

 {-# NOINLINE elts_udfm #-}

 -- traverseUSDFM in the pattern-match checker, which doesn't fuse. Inlining

 -- the size dispatch into it regresses T17836.

 udfmToList (UDFM m ub)

       M.foldrWithKey (\k tv r -> (mkUniqueGrimily k, taggedFst tv) : r) [] m

   | usePigeonholeSort m ub = pigeonholeSort ub

       (\k tv -> TaggedVal (mkUniqueGrimily k, taggedFst tv) (taggedSnd tv)) m

 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

 module Language.Haskell.Syntax.BooleanFormula(

   BooleanFormula(..), LBooleanFormula,

   ) where

 import Prelude hiding ( init, last )

 import Data.List ( nub )

 -- types

 type LBooleanFormula p = XRec p (BooleanFormula p)

 -- instances

 -- smart constructors

 -- see note [Simplification of BooleanFormulas]

 mkVar = Var

 -- Convert a Bool to a BooleanFormula

 mkBool False = mkFalse

 mkBool True  = mkTrue

 -- Make a conjunction, and try to simplify

 mkAnd = maybe mkFalse (mkAnd' . nub . concat) . mapM fromAnd

   where

   -- See Note [Simplification of BooleanFormulas]

   fromAnd :: LBooleanFormula p -> Maybe [LBooleanFormula p]

   fromAnd bf = case unXRec @p bf of

      -- assume that xs are already simplified

      -- otherwise we would need: fromAnd (And xs) = concat <$> traverse fromAnd xs

      -- in case of False we bail out, And [..,mkFalse,..] == mkFalse

     _        -> Just [bf]

   mkAnd' [x] = unXRec @p x

 mkOr = maybe mkTrue (mkOr' . nub . concat) . mapM fromOr

   where

   -- See Note [Simplification of BooleanFormulas]

   fromOr bf = case unXRec @p bf of

   mkOr' [x] = unXRec @p x

 type family XStringLit  x

 type family XXStringLit x

 -- =====================================================================

 -- Misc

   let script = intercalate " "

                [ "exec python3 2>/dev/null"

                , "-c"

                ]

   (_,_,_,p) <- createProcess (shell script)

   waitForProcess p >>= print