# clangd

 .clangd

 dist-newstyle/

   NIX_SYSTEM        On Darwin, the target platform of the desired toolchain

                     (either "x86-64-darwin" or "aarch-darwin")

   NO_BOOT           Whether to run ./boot or not, used when testing the source dist

 Environment variables determining build configuration of Hadrian system:

                     This tests the "reinstall" configuration

   CROSS_EMULATOR    The emulator to use for testing of cross-compilers.

   GHC           Path of GHC executable to use for bootstrapping.

   CABAL         Path of cabal-install executable to use for bootstrapping.

   ALEX          Path of alex executable to use for bootstrapping.

   HAPPY         Path of alex executable to use for bootstrapping.

   GHC_VERSION   Which GHC version to fetch for bootstrapping.

   CABAL_INSTALL_VERSION

   case "$MSYSTEM" in

     CLANG64)

       target_triple="x86_64-unknown-mingw32"

       ;;

     *)

       fail "win32-init: Unknown MSYSTEM $MSYSTEM"

   MINGW_MOUNT_POINT="${MINGW_PREFIX}"

   PATH="$MINGW_MOUNT_POINT/bin:$PATH"

 }

 # This will contain GHC's local native toolchain

 }

 function set_toolchain_paths() {

     extracted)

       # These are populated by setup_toolchain

       GHC="$toolchain/bin/ghc$exe"

       : ${HAPPY:=$(which happy)}

       : ${ALEX:=$(which alex)}

       ;;

   esac

   export GHC

       cp -Rf "$CABAL_CACHE"/* "$CABAL_DIR"

   fi

     extracted) time_it "setup" setup_toolchain ;;

     *) ;;

   esac

 }

 function fetch_ghc() {

       if [[ -z "$v" ]]; then

           fail "neither GHC nor GHC_VERSION are not set"

       fi

       start_section "fetch GHC"

       info "Fetching GHC binary distribution from $url..."

       curl "$url" > ghc.tar.xz || fail "failed to fetch GHC binary distribution"

       $TAR -xJf ghc.tar.xz || fail "failed to extract GHC binary distribution"

       esac

       rm -Rf "ghc-${GHC_VERSION}" ghc.tar.xz

       end_section "fetch GHC"

 }

 function fetch_cabal() {

 # here. For Docker platforms this is done in the Docker image

 # build.

 function setup_toolchain() {

   fetch_ghc

   fetch_cabal

   cabal_update

   if [[ -n "${target_triple:-}" ]]; then

     args+=("--target=$target_triple")

   fi

   if [[ -n "${ENABLE_NUMA:-}" ]]; then

     args+=("--enable-numa")

     else

   # See https://stackoverflow.com/questions/7577052 for a rationale for the

   # args[@] symbol-soup below.

   run ${CONFIGURE_WRAPPER:-} ./configure \

     "${args[@]+"${args[@]}"}" \

     GHC="$GHC" \

     || ( cat config.log; fail "configure failed" )

       read -r -a args <<< "${INSTALL_CONFIGURE_ARGS:-}"

       if [[ "${CROSS_TARGET:-no_cross_target}" =~ "mingw" ]]; then

           # By the fact above it is clearly turning out which host value is

           # for currently built compiler.

           # The fix for #21970 will probably remove this if-branch.

       # FIXME: The bindist configure script shouldn't need to be reminded of

       # the target platform. See #21970.

 MAKE="make"

 TAR="tar"

 case "$(uname)" in

   FreeBSD)

     MAKE="gmake"

     TAR="gtar"

     ;;

         . setVariable "WindresCmd" (llvm_prefix ++ "windres")

         . setVariable "LLVMAS" (llvm_prefix ++ "clang")

         . setVariable "LD" (llvm_prefix ++ "ld")

           -- Windows target require to make linker merge feature check disabled.

         . setVariable "MergeObjsCmd" ""

           -- LLVM MinGW Linux Toolchain expects to recieve "aarch64-w64-mingw32"

           -- as a triple but we use more common "aarch64-unknown-mingw32".

           -- it will use system's ld otherwise when --target will be specified to

           -- unexpected triple.

         . setVariable "CFLAGS" cflags

         . setVariable "CONF_CC_OPTS_STAGE2" cflags

         ) where

             llvm_prefix = "/opt/llvm-mingw-linux/bin/aarch64-w64-mingw32-"

             cflags = "-fuse-ld=" ++ llvm_prefix ++ "ld --rtlib=compiler-rt"

     winAarch64Config = (crossConfig "aarch64-unknown-mingw32" (Emulator "/opt/wine-arm64ec-msys2-deb12/bin/wine") Nothing)

     # Run autoreconf on everything that needs it.

     processes = {}

     if os.name == 'nt':

         # Get the normalized ACLOCAL_PATH for Windows

         # This is necessary since on Windows this will be a Windows

         # path, which autoreconf doesn't know doesn't know how to handle.

 import GHC.Builtin.Types

 import GHC.Builtin.Types.Prim

 import GHC.Tc.Solver.InertSet (InertSet, emptyInert)

 import GHC.Types.CompleteMatch

 import GHC.Types.SourceText (SourceText(..), mkFractionalLit, FractionalLit

                             , fractionalLitFromRational

   ppr (TySt n inert) = ppr n <+> ppr inert

 initTyState :: TyState

 -- | The term oracle state. Stores 'VarInfo' for encountered 'Id's. These

 -- entries are possibly shared when we figure out that two variables must be

         setupBreakpoint,

         back, forward,

         setContext, getContext,

         getNamesInScope,

         getRdrNamesInScope,

         moduleIsInterpreted,

       Nothing -> pure $ Left "not a home module"

       Just details ->

          case mi_top_env (hm_iface details) of

                   let exports_env = mkGlobalRdrEnv $ gresFromAvails hsc_env Nothing (getDetOrdAvails exports)

                   pure $ Right $ plusGlobalRdrEnv imports_env exports_env

   where

     hpt = hsc_HPT hsc_env

 -- | Get the interactive evaluation context, consisting of a pair of the

 -- set of modules from which we take the full top-level scope, and the set

 -- of modules from which we take just the exports respectively.

        ; let psig_theta = concatMap sig_inst_theta partial_sigs

        -- First do full-blown solving

        ; ev_binds_var <- TcM.newTcEvBinds

        ; psig_evs     <- newWanteds AnnOrigin psig_theta

        ; wanted_transformed

                solveWanteds (mkSimpleWC psig_evs `andWC` wanteds)

                -- psig_evs : see Note [Add signature contexts as wanteds]

        -- Find quant_pred_candidates, the predicates that

        -- we'll consider quantifying over

              -- Step 1 of Note [decideAndPromoteTyVars]

              -- Get candidate constraints, decide which we can potentially quantify

              can_quant = ctsPreds can_quant_cts

              -- Step 2 of Note [decideAndPromoteTyVars]

              -- Apply the monomorphism restriction

              (post_mr_quant, mr_no_quant) = applyMR dflags infer_mode can_quant

              -- The co_var_tvs are tvs mentioned in the types of covars or

              -- coercion holes. We can't quantify over these covars, so we

                                          ++ tau_tys ++ post_mr_quant)

              co_var_tvs = closeOverKinds co_vars

              -- We definitely can't quantify over them

              outer_tvs = outerLevelTyVars rhs_tclvl $

              -- Identify mono_tvs: the type variables that we must not quantify over

              mono_tvs_without_mr

              mono_tvs_with_mr

                = -- Even at top level, we don't quantify over type variables

                  -- mentioned in constraints that the MR tells us not to quantify

                  -- See Note [decideAndPromoteTyVars] (DP2)

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

              -- Step 4 of Note [decideAndPromoteTyVars]

              -- Use closeWrtFunDeps to find any other variables that are determined by mono_tvs

                  -- Why delVarSetList psig_qtvs?

                  -- If the user has explicitly asked for quantification, then that

                  -- request "wins" over the MR.

                  -- (i.e. says "no" to isQuantifiableTv)? That's OK: explanation

                  -- in Step 2 of Note [Deciding quantification].

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

              -- Step 5 of Note [decideAndPromoteTyVars]

            , text "newly_mono_tvs =" <+> ppr newly_mono_tvs

            , text "can_quant =" <+> ppr can_quant

            , text "post_mr_quant =" <+> ppr post_mr_quant

            , text "mr_no_quant =" <+> ppr mr_no_quant

            , text "final_quant =" <+> ppr final_quant

            , text "co_vars =" <+> ppr co_vars ]

   The body of z tries to unify the type of x (call it alpha[1]) with

   (beta[2] -> gamma[2]). This unification fails because alpha is untouchable, leaving

        [W] alpha[1] ~ (beta[2] -> gamma[2])

   Another example. Suppose we have

       class C a b | a -> b

   promote type variables.  But for bindings affected by the MR we have no choice

   but to promote.

 Note [The top-level Any principle]

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

 Most /top level/ bindings have a type signature, so none of this arises.  But

 where a top-level binding lacks a signature, we don't want to infer a type like

 bad bad.  Better to report an error, which is what may well happen if we

 quantify over alpha instead.

 For /nested/ bindings, a monomorphic type like `f :: alpha[0] -> Int` is fine,

 because we can see all the call sites of `f`, and they will probably fix

 `alpha`.  In contrast, we can't see all of (or perhaps any of) the calls of

 top-level (exported) functions, reducing the worries about "spooky action at a

 Note [Do not quantify over constraints that determine a variable]

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

          where

            dicts = bagToList (dictsToBag solved_dicts)

   = IC { inert_eqs          = emptyTyEqs

        , inert_funeqs       = emptyFunEqs

        , inert_given_eqs    = False

        , inert_dicts        = emptyDictMap

        , inert_safehask     = emptyDictMap

        , inert_insts        = []

        , inert_irreds       = emptyBag }

        , inert_cycle_breakers = emptyBag :| []

        , inert_famapp_cache   = emptyFunEqs

        , inert_solved_dicts   = emptyDictMap }

    imply nominal ones. For example, if (G a ~R G b) and G's argument's

    role is nominal, then we can deduce a ~N b.

 Historical note: prior to #24938 we also ignored Given equalities that

 did not mention an "outer" type variable.  But that is wrong, as #24938

 showed. Another example is immortalised in test LocalGivenEqs2

     runTcSSpecPrag,

     failTcS, warnTcS, addErrTcS, wrapTcS, ctLocWarnTcS,

     runTcSEqualities,

     emitImplicationTcS, emitTvImplicationTcS,

     emitImplication,

     emitFunDepWanteds,

 -- | See Note [TcSMode]

 data TcSMode

   = TcSVanilla    -- ^ Normal constraint solving

   | TcSEarlyAbort -- ^ Abort early on insoluble constraints

   deriving (Eq)

 {- Note [TcSMode]

 * TcSVanilla: Normal constraint solving mode. This is the default.

 * TcSEarlyAbort: Abort (fail in the monad) as soon as we come across an

   insoluble constraint. This is used to fail-fast when checking for hole-fits.

   See Note [Speeding up valid hole-fits].

 runTcSEarlyAbort :: TcS a -> TcM a

 runTcSEarlyAbort tcs

   = do { ev_binds_var <- TcM.newTcEvBinds

 -- | Run the 'TcS' monad in 'TcSSpecPrag' mode, which either fully solves

 -- individual Wanted quantified constraints or leaves them alone.

 -- See Note [TcSSpecPrag].

 runTcSSpecPrag :: EvBindsVar -> TcS a -> TcM a

 runTcSSpecPrag ev_binds_var tcs

 {- Note [TcSSpecPrag]

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

 runTcSInerts :: InertSet -> TcS a -> TcM (a, InertSet)

 runTcSInerts inerts tcs = do

   ev_binds_var <- TcM.newTcEvBinds

     setInertSet inerts

     a <- tcs

     new_inerts <- getInertSet

 runTcSWithEvBinds :: EvBindsVar

                   -> TcS a

                   -> TcM a

                    -> EvBindsVar

                    -> TcS a

                    -> TcM a

   = do { unified_var <- TcM.newTcRef 0

        ; unif_lvl_var <- TcM.newTcRef Nothing

        ; let env = TcSEnv { tcs_ev_binds           = ev_binds_var

                           , tcs_unified            = unified_var

        ; when (count > 0) $

          csTraceTcM $ return (text "Constraint solver steps =" <+> int count)

 #if defined(DEBUG)

        ; ev_binds <- TcM.getTcEvBindsMap ev_binds_var

 setEvBindsTcS ref (TcS thing_inside)

  = TcS $ \ env -> thing_inside (env { tcs_ev_binds = ref })

 nestImplicTcS :: EvBindsVar

               -> TcLevel -> TcS a

               -> TcS a

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

 -}

 approximateWC :: Bool -> WantedConstraints -> Bag Ct

 approximateWC include_non_quantifiable cts

 -- The "X" means "extended";

 --    we return both quantifiable and non-quantifiable constraints

 -- See Note [ApproximateWC]

 -- See Note [floatKindEqualities vs approximateWC]

   where

     float_wc :: Bool           -- True <=> there are enclosing equalities

              -> TcTyCoVarSet   -- Enclosing skolem binders

            -- There can be (insoluble) Given constraints in wc_simple,

            -- there so that we get error reports for unreachable code

            -- See `given_insols` in GHC.Tc.Solver.Solve.solveImplication

            -- See the classification in Note [ApproximateWC]

            EqPred eq_rel ty1 ty2

            ClassPred cls tys

              | Just {} <- isCallStackPred cls tys

                -- the constraints bubble up to be solved from the outer

                -- context, or be defaulted when we reach the top-level.

                -- See Note [Overview of implicit CallStacks] in GHC.Tc.Types.Evidence

              | otherwise

     -- See Note [Quantifying over equality constraints]

     quantify_equality NomEq  ty1 ty2 = quant_fun ty1 || quant_fun ty2

 Wrinkle (W1)

   When inferring most-general types (in simplifyInfer), we

   equality constraints, because that defeats the OutsideIn story.

   Consider data T a where { TInt :: T Int; MkT :: T a }

          f TInt = 3::Int

         plusOccEnv, plusOccEnv_C,

         extendOccEnv_Acc, filterOccEnv, delListFromOccEnv, delFromOccEnv,

         alterOccEnv, minusOccEnv, minusOccEnv_C, minusOccEnv_C_Ns,

         pprOccEnv, forceOccEnv,

         intersectOccEnv_C,

            then Nothing

            else Just m

 instance Outputable a => Outputable (OccEnv a) where

     ppr x = pprOccEnv ppr x

 AC_SUBST(LlvmTarget)

 dnl ** See whether cc supports --target=<triple> and set

 FP_CC_SUPPORTS_TARGET([$CC], [CONF_CC_OPTS_STAGE1], [CONF_CXX_OPTS_STAGE1])

 FP_CC_SUPPORTS_TARGET([$CC], [CONF_CC_OPTS_STAGE2], [CONF_CXX_OPTS_STAGE2])

 FP_PROG_CC_LINKER_TARGET([$CC], [CONF_CC_OPTS_STAGE1], [CONF_GCC_LINKER_OPTS_STAGE1])

 FP_PROG_CC_LINKER_TARGET([$CC], [CONF_CC_OPTS_STAGE2], [CONF_GCC_LINKER_OPTS_STAGE2])

 import Hadrian.Oracles.Path

 import Hadrian.Oracles.TextFile

 import Hadrian.Utilities

 import System.Exit

 import System.IO (stderr)

                 Ar Unpack _ -> cmd' [Cwd output] [path] buildArgs buildOptions

                 Autoreconf dir -> do