-- EarlyDerivSpec from it.

 mk_eqn_from_mechanism :: DerivSpecMechanism -> DerivM EarlyDerivSpec

 mk_eqn_from_mechanism mechanism

        user_ctxt <- askDerivUserTypeCtxt

        doDerivInstErrorChecks1 mechanism

        loc       <- lift getSrcSpanM

        case deriv_ctxt of

         InferContext wildcard ->

           do { (inferred_constraints, tvs', inst_tys', mechanism')

              ; return $ InferTheta $ DS

                    { ds_loc = loc

                    , ds_name = dfun_name, ds_tvs = tvs'

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

                  -> DerivM (ThetaSpec, [TyVar], [TcType], DerivSpecMechanism)

 -- inferConstraints figures out the constraints needed for the

 -- instance declaration generated by a 'deriving' clause on a

 -- Generate a sufficiently large set of constraints that typechecking the

 -- generated method definitions should succeed.   This set will be simplified

 -- before being used in the instance declaration

              infer_constraints =

                case mechanism of

                  DerivSpecStock{dsm_stock_dit = dit}

                                         , dit_tc_args     = tc_args

                                         , dit_rep_tc      = rep_tc

                                         , dit_rep_tc_args = rep_tc_args })

                 , denv_cls      = main_cls

                 , denv_inst_tys = inst_tys } <- ask

            tc_binders = tyConBinders rep_tc

            choose_level bndr

              | isNamedTyConBinder bndr = KindLevel

 -- derived instance context.

 inferConstraintsAnyclass :: DerivM ThetaSpec

 inferConstraintsAnyclass

                   , denv_inst_tys  = inst_tys } <- ask

        ; let gen_dms = [ (sel_id, dm_ty)

                        | (sel_id, Just (_, GenericDM dm_ty)) <- classOpItems cls ]

                -- (Id,Type) are the selector Id and the generic default method type

                -- NB: the latter is /not/ quantified over the class variables

                -- See Note [Gathering and simplifying constraints for DeriveAnyClass]

 inferConstraintsCoerceBased :: [Type] -> Type

                             -> DerivM ThetaSpec

 inferConstraintsCoerceBased cls_tys rep_ty = do

            , denv_cls      = cls

            , denv_inst_tys = inst_tys } <- ask

   let -- rep_ty might come from:

       --   GeneralizedNewtypeDeriving / DerivSpecNewtype:

       --       the underlying type of the newtype ()

               -- we are going to get all the methods for the final

               -- dictionary

       deriv_origin = mkDerivOrigin sa_wildcard

       -- Next we collect constraints for the class methods

       -- If there are no methods, we don't need any constraints

 T20815a):

   class Alt f where

   newtype T f a = T (f a) deriving Alt

 import GHC.Tc.Deriv.Functor

 import GHC.Tc.Deriv.Generics

 import GHC.Tc.Errors.Types

 import GHC.Tc.Types.Origin

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Zonk.Type

 import GHC.Core.Class

 import GHC.Utils.Unique (sameUnique)

 import Control.Monad.Trans.Reader

 import Data.Maybe

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Data.List.SetOps (assocMaybe)

 -- | Is GHC processing a standalone deriving declaration with an

 -- extra-constraints wildcard as the context?

 -- (e.g., @deriving instance _ => Eq (Foo a)@)

 -- | Return 'InstDeclCtxt' if processing with a standalone @deriving@

 -- declaration or 'DerivClauseCtxt' if processing a @deriving@ clause.

     SimplePredSpec

       { sps_pred :: TcPredType

         -- ^ The constraint to emit as a wanted

       , sps_origin :: CtOrigin

         -- ^ The origin of the constraint

       , sps_type_or_kind :: TypeOrKind

         -- ^ Whether the constraint is a type or kind

       }

   | -- | A special 'PredSpec' that is only used by @DeriveAnyClass@. This

     -- will check if @stps_ty_actual@ is a subtype of (i.e., more polymorphic

     -- than) @stps_ty_expected@ in the constraint solving machinery, emitting an

                   -- @deriving@ declaration

   -> ThetaSpec    -- ^ The specs from which constraints will be created

   -> TcM (TcLevel, WantedConstraints)

   where

     -- Create the constraints we need to solve. For stock and newtype

     -- deriving, these constraints will be simple wanted constraints

     mk_wanteds :: ThetaSpec -> TcM WantedConstraints

     mk_wanteds preds

       = do { (_, wanteds) <- captureConstraints $

            ; pure wanteds }

 {-

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

   (<!>) = (++)

 newtype L a = L [a] deriving (Functor, Alt)