Wrinkles

 (W2) We need two absent-error Ids, aBSENT_ERROR_ID for types of kind Type, and

      aBSENT_CONSTRAINT_ERROR_ID for types of kind Constraint.

      of type TYPE rr. See (CPR2) in Note [Which types are unboxed?] in

      GHC.Core.Opt.WorkWrap.Utils.

 Type and Constraint are not equal (eqType) but they are not /apart/

 either. Reason (c.f. #7451):

      So in GHC.Tc.Instance.Class.matchTypeable, Type and Constraint are

      treated as separate TyCons; i.e. given no special treatment.

 Note [RuntimeRep polymorphism]

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

 Generally speaking, you can't be polymorphic in `RuntimeRep`.  E.g

 -- | Given a coercion `co :: (t1 :: TYPE r1) ~ (t2 :: TYPE r2)`

 -- produce a coercion `rep_co :: r1 ~ r2`

 mkRuntimeRepCo :: HasDebugCallStack => Coercion -> Coercion

 mkRuntimeRepCo co

   = assert (isTYPEorCONSTRAINT k1 && isTYPEorCONSTRAINT k2) $

     kind_co = mkKindCo co  -- kind_co :: TYPE r1 ~ TYPE r2

     Pair k1 k2 = coercionKind kind_co

 isReflCoVar_maybe :: Var -> Maybe Coercion

 -- If cv :: t~t then isReflCoVar_maybe cv = Just (Refl t)

 -- Works on all kinds of Vars, not just CoVars

        , Just (tc2, tys2) <- splitTyConApp_maybe ty2

        , let { len1 = length tys1

              ; len2 = length tys2 }

        && len1 == len2

        && n < len1

        && r == tyConRole (coercionRole co) tc1 n

          hang (text "Inhomogeneous axiom")

             2 (text "lhs:" <+> ppr lhs <+> dcolon <+> ppr lhs_kind $$

                text "rhs:" <+> ppr rhs <+> dcolon <+> ppr rhs_kind) }

 lint_family_branch :: TyCon -> CoAxBranch -> LintM ()

 lint_family_branch fam_tc br@(CoAxBranch { cab_tvs     = tvs

                                          , cab_eta_tvs = eta_tvs

                                          , cab_cvs     = cvs

 import GHC.Utils.Outputable

 import GHC.Types.Name

 import GHC.Types.Name.Env

 import Control.Monad (join)

 import Data.Data (Data)

 roughMatchTyConName :: TyCon -> Name

 roughMatchTyConName tc

 -- | Trie of @[RoughMatchTc]@

 --

                       Nothing  -> pprPanic "piResultTy" (ppr ty $$ ppr arg)

 piResultTy_maybe :: Type -> Type -> Maybe Type

 piResultTy_maybe ty arg = case coreFullView ty of

   FunTy { ft_res = res } -> Just res

 import GHC.Types.Var

 import GHC.Types.Var.Env

 import GHC.Types.Var.Set

 import GHC.Core.Type     hiding ( getTvSubstEnv )

 import GHC.Core.Coercion hiding ( getCvSubstEnv )

 import GHC.Core.Predicate( scopedSort )

          See Note [Apartness and type families]

     * MARInfinite (occurs check):

          See Note [Infinitary substitutions]

     * MARCast (obscure):

          See (KCU2) in Note [Kind coercions in Unify]

 -- | Why are two types 'MaybeApart'? 'MARInfinite' takes precedence:

 -- This is used (only) in Note [Infinitary substitution in lookup] in GHC.Core.InstEnv

 data MaybeApartReason

   = MARTypeFamily   -- ^ matching e.g. F Int ~? Bool

   | MARInfinite     -- ^ matching e.g. a ~? Maybe a

   | MARCast         -- ^ Very obscure.

     -- See (KCU2) in Note [Kind coercions in Unify]

 -- See (UR1) in Note [Unification result] for why MARInfinite wins

 combineMAR MARInfinite         _ = MARInfinite   -- MARInfinite wins

 combineMAR MARTypeFamily       r = r             -- Otherwise it doesn't really matter

 combineMAR MARCast             r = r

 instance Outputable MaybeApartReason where

   ppr MARTypeFamily       = text "MARTypeFamily"

   ppr MARInfinite         = text "MARInfinite"

   ppr MARCast             = text "MARCast"

 instance Semigroup MaybeApartReason where

        ; unify_tc_app env tc1 tys1 tys2

        }

   where

     mb_tc_app1 = splitTyConApp_maybe ty1

     mb_tc_app2 = splitTyConApp_maybe ty2

 import Data.Functor ((<&>))

 import Data.List ( nub, isPrefixOf, partition )

 import qualified Data.List.NonEmpty as NE

 import Control.Monad

 import Data.IORef

 import System.FilePath as FilePath

         if | not (backendGeneratesCode (backend lcl_dflags)) -> do

                -- No need for a linkable, we're good to go

                msg UpToDate

            | not (backendGeneratesCodeForHsBoot (backend lcl_dflags))

            , IsBoot <- isBootSummary mod_summary -> do

                msg UpToDate

            -- Always recompile with the JS backend when TH is enabled until

            -- #23013 is fixed.

                let just_o = justObjects <$> obj_linkable

                    bytecode_or_object_code

                       | otherwise = (justBytecode <$> maybe_bc) `choose` just_o

                    definitely_bc = bc_obj_linkable `prefer` bc_in_memory_linkable

                    -- If not -fwrite-byte-code, then we could use core bindings or object code if that's available.

                    bc_result = if gopt Opt_WriteByteCode lcl_dflags

                                 -- If the byte-code artifact needs to be produced, then we certainly need bytecode.

                                 else maybe_bc

                trace_if (hsc_logger hsc_env)

 -- | Attempt to load bytecode from whole core bindings in the interface if they exist.

 -- This is a legacy code-path, these days it should be preferred to use the bytecode object linkable.

 checkByteCodeFromIfaceCoreBindings _hsc_env iface mod_sum = do

     let

       this_mod   = ms_mod mod_sum

       if_date    = fromJust $ ms_iface_date mod_sum

     case iface_core_bindings iface (ms_location mod_sum) of

       _ -> return $ outOfDateItemBecause MissingBytecode Nothing

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

   HscEnv ->

   ModIface ->

   ModDetails ->

   where

         add_iface_to_hpt iface details hsc_env

         bco <- unsafeInterleaveIO $

 -- | Hydrate interface Core bindings and compile them to bytecode.

 --

 import GHC.Unit.Finder

 import GHC.Unit.Module.ModSummary

 import GHC.Unit.Module.ModIface

 import GHC.Unit.Home.ModInfo

 import GHC.Unit.Home.PackageTable

    (iface, linkable) <- runPipeline (hsc_hooks plugin_hsc_env) pipeline

    -- See Note [ModDetails and --make mode]

    details <- initModDetails plugin_hsc_env iface

  where lcl_dflags  = ms_hspp_opts summary

        location    = ms_location summary

            $ phaseIfFlag hsc_env flag def action

 -- | The complete compilation pipeline, from start to finish

 fullPipeline pipe_env hsc_env pp_fn src_flavour = do

   (dflags, input_fn) <- preprocessPipeline pipe_env hsc_env pp_fn

   let hsc_env' = hscSetFlags dflags hsc_env

   hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status)

 -- | Everything after preprocess

 hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status) = do

   case hsc_recomp_status of

     HscUpToDate iface mb_linkable -> return (iface, mb_linkable)

       hscBackendAction <- use (T_HscPostTc hsc_env_with_plugins mod_sum tc_result warnings mb_old_hash )

       hscBackendPipeline pipe_env hsc_env_with_plugins mod_sum hscBackendAction

 hscBackendPipeline pipe_env hsc_env mod_sum result =

   if backendGeneratesCode (backend (hsc_dflags hsc_env)) then

     do

       return res

   else

     case result of

 hscGenBackendPipeline :: P m

   => PipeEnv

   -> HscEnv

   -> ModSummary

   -> HscBackendAction

 hscGenBackendPipeline pipe_env hsc_env mod_sum result = do

   let mod_name = moduleName (ms_mod mod_sum)

       src_flavour = (ms_hsc_src mod_sum)

   (fos, miface, mlinkable, o_file) <- use (T_HscBackend pipe_env hsc_env mod_name src_flavour location result)

   final_fp <- hscPostBackendPipeline pipe_env hsc_env (ms_hsc_src mod_sum) (backend (hsc_dflags hsc_env)) (Just location) o_file

   final_linkable <-

       -- No object file produced, bytecode or NoBackend

       Nothing -> return mlinkable

       Just o_fp -> do

    as :: P m => Bool -> m (Maybe FilePath)

    as use_cpp = asPipeline use_cpp pipe_env hsc_env Nothing input_fn

    objFromLinkable _ = Nothing

    fromPhase :: P m => Phase -> m (Maybe FilePath)

 import GHC.Unit.Env

 import GHC.Unit.Finder

 import GHC.Unit.Module

 import GHC.Unit.Home.ModInfo

 import GHC.Iface.Errors.Types

               DotO file ForeignObject -> pure (DotO file ForeignObject)

               DotA fp    -> panic ("adjust_ul DotA " ++ show fp)

               DotDLL fp  -> panic ("adjust_ul DotDLL " ++ show fp)

 {-

 {-# LANGUAGE TypeApplications #-}

 {-# LANGUAGE LambdaCase #-}

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

 --

    , PkgsLoaded

    -- * Linkable

    , mkModuleByteCodeLinkable

    , LinkablePart(..)

    , LinkableObjectSort (..)

 -- | Information we can use to dynamically link modules into the compiler

   { linkableTime     :: !UTCTime

       -- ^ Time at which this linkable was built

       -- (i.e. when the bytecodes were produced,

   , linkableModule   :: !Module

       -- ^ The linkable module itself

     -- ^ Files and chunks of code to link.

 type LinkableSet = ModuleEnv Linkable

       | linkableTime l1 > linkableTime l2 = l1

       | otherwise = l2

   ppr (Linkable when_made mod parts)

      = (text "Linkable" <+> parens (text (show when_made)) <+> ppr mod)

        $$ nest 3 (ppr parts)

   | DotDLL FilePath

       -- ^ Dynamically linked library file (.so, .dll, .dylib)

   | DotGBC ModuleByteCode

     -- ^ A byte-code object, lives only in memory.

   ppr (DotA path)       = text "DotA" <+> text path

   ppr (DotDLL path)     = text "DotDLL" <+> text path

   ppr (DotGBC bco)      = text "DotGBC" <+> ppr bco

 -- | Return true if the linkable only consists of native code (no BCO)

 linkableIsNativeCodeOnly :: Linkable -> Bool

   DotA {}         -> True

   DotDLL {}       -> True

   DotGBC {}       -> False

 -- | Is the part a native library? (.so/.dll)

 isNativeLib :: LinkablePart -> Bool

   DotA {}         -> True

   DotDLL {}       -> True

   DotGBC {}       -> False

 -- | Get the FilePath of linkable part (if applicable)

 linkablePartPath :: LinkablePart -> Maybe FilePath

   DotO fn _       -> Just fn

   DotA fn         -> Just fn

   DotDLL fn       -> Just fn

   DotGBC {}       -> Nothing

 -- | Return the paths of all object code files (.o, .a, .so) contained in this

   DotO fn _       -> [fn]

   DotA fn         -> [fn]

   DotDLL fn       -> [fn]

   DotGBC {}       -> []

 -- | Return the paths of all object files (.o) contained in this 'LinkablePart'.

   DotO fn _ -> [fn]

   DotA _ -> []

   DotDLL _ -> []

   DotGBC bco -> gbc_foreign_files bco

 -- | Retrieve the compiled byte-code from the linkable part.

   Just linkable {linkableParts = new}

 linkablePartNative :: LinkablePart -> [LinkablePart]

   DotGBC bco -> [DotO f ForeignObject | f <- gbc_foreign_files bco]

 linkablePartByteCode :: LinkablePart -> [LinkablePart]

 linkablePartByteCode = \case

   | k `eqType` naturalTy      = doTyLit knownNatClassName         t

   | k `eqType` typeSymbolKind = doTyLit knownSymbolClassName      t

   | k `eqType` charTy         = doTyLit knownCharClassName        t

   | Just (tc, ks) <- splitTyConApp_maybe t -- See Note [Typeable (T a b c)]

   , onlyNamedBndrsApplied tc ks            = doTyConApp clas t tc ks

 module GHC.Unit.Home.ModInfo

    (

      HomeModInfo (..)

    , homeModInfoObject

    , homeModInfoByteCode

    , emptyHomeModInfoLinkable

    )

 where

 import GHC.Unit.Module.ModIface

 import GHC.Unit.Module.ModDetails

 import GHC.Utils.Outputable

 -- | Information about modules in the package being compiled

 data HomeModInfo = HomeModInfo

 instance Outputable HomeModLinkable where

   ppr (HomeModLinkable l1 l2) = ppr l1 $$ ppr l2

 {-

 Note [Home module build products]

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

 module GHC.Unit.Module.Status

    )

 where

 import GHC.Prelude

 import GHC.Unit

 import GHC.Unit.Module.ModGuts

 import GHC.Unit.Module.ModIface

 import GHC.Utils.Fingerprint

 import GHC.Utils.Outputable

 -- | Status of a module in incremental compilation

 data HscRecompStatus

     -- | Nothing to do because code already exists.

     -- | Recompilation of module, or update of interface is required. Optionally

     -- pass the old interface hash to avoid updating the existing interface when

     -- it has not changed.

           -- changed.

         }

 instance Outputable HscRecompStatus where

   ppr HscUpToDate{} = text "HscUpToDate"

   ppr HscRecompNeeded{} = text "HscRecompNeeded"

 instance Outputable HscBackendAction where

   ppr (HscUpdate mi) = text "Update:" <+> (ppr (mi_module mi))

   ppr (HscRecomp _ ml _mi _mf) = text "Recomp:" <+> ppr ml

             , wcb_foreign :: IfaceForeign

             }

 {-

 Note [Foreign stubs and TH bytecode linking]

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

      # excessive amounts of stack space. So we specifically set a low

      # stack limit and mark it as failing under a few conditions.

      [extra_run_opts('+RTS -K8m -RTS'),

      # JS doesn't support stack limit so the test sometimes passes just fine. Therefore the test is

      # marked as fragile.

      when(js_arch(), fragile(22921))],

     """

     req_interp(name, opts)

     if config.cross:

         opts.skip = True

 test('T20696', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , unless(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 test('T20696-static', [extra_files(['A.hs', 'B.hs', 'C.hs'])

                , when(ghc_dynamic(), skip)], multimod_compile, ['A', ''])

 # Check linking works when using -fbyte-code-and-object-code

 test('fat011', [req_th, extra_files(['FatMain.hs', 'FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatMain', '-fbyte-code-and-object-code -fprefer-byte-code'])

 # Check that we use interpreter rather than enable dynamic-too if needed for TH

 # Check that no objects are generated if using -fno-code and -fprefer-byte-code

 test('fat013', [req_th, req_bco, extra_files(['FatTH.hs', 'FatQuote.hs'])], multimod_compile, ['FatTH', '-fno-code -fprefer-byte-code'])

 # When using interpreter should not produce objects

 test('fat014', [req_th, extra_files(['FatTH.hs', 'FatQuote.hs']), extra_run_opts('-fno-code')], ghci_script, ['fat014.script'])

 test('T22807', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807A.hs', 'T22807B.hs'])]

              , makefile_test, ['T22807'])

 test('T22807_ghci', [req_th, unless(ghc_dynamic(), skip), extra_files(['T22807_ghci.hs'])]

 type instance F Type = Int

 type instance F Constraint = Bool

 test('T8368a', normal, compile_fail, [''])

 test('T8518', normal, compile_fail, [''])