GHC.Tc.Deriv.Utils

Error-checking and other utilities for deriving clauses or declarations.

Documentation

type DerivM = ReaderT DerivEnv TcRn

To avoid having to manually plumb everything in DerivEnv throughout various functions in GHC.Tc.Deriv and GHC.Tc.Deriv.Infer, we use DerivM, which is a simple reader around TcRn.

data DerivEnv

Contains all of the information known about a derived instance when determining what its EarlyDerivSpec should be. See Note [DerivEnv and DerivSpecMechanism].

Constructors

DerivEnv

Fields

• denv_overlap_mode :: Maybe OverlapMode

  Is this an overlapping instance?

• denv_tvs :: [TyVar]

  Universally quantified type variables in the instance. If the denv_ctxt is InferContext, these will be TcTyVar skolems. If the denv_ctxt is SupplyContext, these will be ordinary TyVars. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.

  All type variables that appear in the denv_inst_tys, denv_ctxt, denv_skol_info, and denv_strat should come from denv_tvs.

• denv_cls :: Class

  Class for which we need to derive an instance

• denv_inst_tys :: [Type]

  All arguments to denv_cls in the derived instance.

• denv_ctxt :: DerivContext

  SupplyContext theta for standalone deriving (where theta is the context of the instance). InferContext for deriving clauses, or for standalone deriving that uses a wildcard constraint. See Note [Inferring the instance context].

• denv_skol_info :: SkolemInfo

  The SkolemInfo used to skolemise the denv_tvs in the case where the denv_ctxt is InferContext.

• denv_strat :: Maybe (DerivStrategy GhcTc)

  Just if user requests a particular deriving strategy. Otherwise, Nothing.

Instances

Outputable DerivEnv

Defined in GHC.Tc.Deriv.Utils

Methods

ppr :: DerivEnv -> SDoc

data DerivSpec theta

Constructors

DS

Fields

• ds_loc :: SrcSpan
• ds_name :: Name
• ds_tvs :: [TyVar]
• ds_theta :: theta
• ds_cls :: Class
• ds_tys :: [Type]
• ds_skol_info :: SkolemInfo
• ds_user_ctxt :: UserTypeCtxt
• ds_overlap :: Maybe OverlapMode
• ds_standalone_wildcard :: Maybe SrcSpan
• ds_mechanism :: DerivSpecMechanism

Instances

Outputable theta => Outputable (DerivSpec theta)

Defined in GHC.Tc.Deriv.Utils

Methods

ppr :: DerivSpec theta -> SDoc

pprDerivSpec :: Outputable theta => DerivSpec theta -> SDoc

setDerivSpecTheta :: theta' -> DerivSpec theta -> DerivSpec theta'

Set the ds_theta in a DerivSpec.

zonkDerivSpec :: DerivSpec ThetaType -> TcM (DerivSpec ThetaType)

Zonk the TcTyVars in a DerivSpec to TyVars. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.

This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.

data DerivSpecMechanism

What action to take in order to derive a class instance. See Note [DerivEnv and DerivSpecMechanism], as well as Note [Deriving strategies] in GHC.Tc.Deriv.

Constructors

DerivSpecStock

"Standard" classes

Fields

• dsm_stock_dit :: DerivInstTys

  Information about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See Note [DerivEnv and DerivSpecMechanism].

• dsm_stock_gen_fns :: StockGenFns

  How to generate the instance bindings and associated type family instances.

DerivSpecNewtype

GeneralizedNewtypeDeriving

Fields

• dsm_newtype_dit :: DerivInstTys

  Information about the arguments to the class in the derived instance, including what type constructor the last argument is headed by. See Note [DerivEnv and DerivSpecMechanism].

• dsm_newtype_rep_ty :: Type

  The newtype rep type.

DerivSpecAnyClass

DeriveAnyClass

DerivSpecVia

DerivingVia

Fields

• dsm_via_cls_tys :: [Type]

  All arguments to the class besides the last one.

• dsm_via_inst_ty :: Type

  The last argument to the class.

• dsm_via_ty :: Type

  The via type

Instances

Outputable DerivSpecMechanism

Defined in GHC.Tc.Deriv.Utils

Methods

ppr :: DerivSpecMechanism -> SDoc

derivSpecMechanismToStrategy :: DerivSpecMechanism -> DerivStrategy GhcTc

Convert a DerivSpecMechanism to its corresponding DerivStrategy.

isDerivSpecStock :: DerivSpecMechanism -> Bool

isDerivSpecNewtype :: DerivSpecMechanism -> Bool

isDerivSpecAnyClass :: DerivSpecMechanism -> Bool

isDerivSpecVia :: DerivSpecMechanism -> Bool

zonkDerivSpecMechanism :: ZonkEnv -> DerivSpecMechanism -> TcM DerivSpecMechanism

Zonk the TcTyVars in a DerivSpecMechanism to TyVars. See Note [What is zonking?] in GHC.Tc.Utils.TcMType.

This is only used in the final zonking step when inferring the context for a derived instance. See Note [Overlap and deriving] in GHC.Tc.Deriv.Infer.

data DerivContext

Whether GHC is processing a deriving clause or a standalone deriving declaration.

Constructors

InferContext (Maybe SrcSpan)

'InferContext mb_wildcard is either:

• A deriving clause (in which case mb_wildcard is Nothing).
• A standalone deriving declaration with an extra-constraints wildcard as the context (in which case mb_wildcard is Just loc, where loc is the location of the wildcard.

GHC should infer the context.

SupplyContext ThetaType

SupplyContext theta is a standalone deriving declaration, where theta is the context supplied by the user.

Instances

Outputable DerivContext

Defined in GHC.Tc.Deriv.Utils

Methods

ppr :: DerivContext -> SDoc

data OriginativeDerivStatus

Records whether a particular class can be derived by way of an originative deriving strategy (i.e., stock or anyclass).

See Note [Deriving strategies] in GHC.Tc.Deriv.

Constructors

CanDeriveStock StockGenFns

StockClassError !DeriveInstanceErrReason

CanDeriveAnyClass

NonDerivableClass

data StockGenFns

Describes how to generate instance bindings (stock_gen_binds) and associated type family instances (stock_gen_fam_insts) for a particular stock-derived instance.

Constructors

StockGenFns

Fields

• stock_gen_binds :: SrcSpan -> DerivInstTys -> TcM (LHsBinds GhcPs, [LSig GhcPs], Bag AuxBindSpec, [Name])

  Describes how to generate instance bindings for a stock-derived instance.

  This function takes two arguments:

  1. SrcSpan: the source location where the instance is being derived. This will eventually be instantiated with the ds_loc field of a DerivSpec.
  2. DerivInstTys: information about the argument types to which a class is applied in a derived instance. This will eventually be instantiated with the dsm_stock_dit field of a DerivSpecMechanism.

  This function returns four things:

  1. LHsBinds GhcPs: The derived instance's function bindings (e.g., compare (T x) (T y) = compare x y)
  2. [LSig GhcPs]: A list of instance specific signatures/pragmas. Most likely INLINE pragmas for class methods.
  3. Bag AuxBindSpec: Auxiliary bindings needed to support the derived instance. As examples, derived Eq and Ord instances sometimes require top-level con2tag functions. See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate.
  4. [Name]: A list of Names for which -Wunused-binds should be suppressed. This is used to suppress unused warnings for record selectors when deriving Read, Show, or Generic. See Note [Deriving and unused record selectors].
• stock_gen_fam_insts :: SrcSpan -> DerivInstTys -> TcM [FamInst]

  Describes how to generate associated type family instances for a stock-derived instance. This function takes the same arguments as the stock_gen_binds function but returns a list of FamInsts instead. Generating type family instances is done separately from stock_gen_binds since the type family instances must be generated before the instance bindings can be typechecked. See Note [Staging of tcDeriving] in GHC.Tc.Deriv.

isStandaloneDeriv :: DerivM Bool

Is GHC processing a standalone deriving declaration?

isStandaloneWildcardDeriv :: DerivM Bool

Is GHC processing a standalone deriving declaration with an extra-constraints wildcard as the context? (e.g., deriving instance _ => Eq (Foo a))

askDerivUserTypeCtxt :: DerivM UserTypeCtxt

Return InstDeclCtxt if processing with a standalone deriving declaration or DerivClauseCtxt if processing a deriving clause.

mkDerivOrigin :: Bool -> CtOrigin

mkDerivOrigin wc returns StandAloneDerivOrigin if wc is True, and DerivClauseOrigin if wc is False. Useful for error-reporting.

data PredSpec

A PredSpec specifies a constraint to emitted when inferring the instance context for a derived instance in simplifyInfer.

Constructors

SimplePredSpec

An ordinary PredSpec that directly stores a PredType, which will be emitted as a wanted constraint in the constraint solving machinery. This is the simple case, as there are no skolems, metavariables, or given constraints involved.

Fields

• 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

SubTypePredSpec

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 implication constraint as a side effect. For more details on how this works, see Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer.

Fields

• stps_ty_actual :: TcSigmaType

  The actual type. In the context of DeriveAnyClass, this is the default method type signature.

• stps_ty_expected :: TcSigmaType

  The expected type. In the context of DeriveAnyClass, this is the original method type signature.

• stps_origin :: CtOrigin

  The origin of the constraint

Instances

Outputable PredSpec

Defined in GHC.Tc.Deriv.Utils

Methods

ppr :: PredSpec -> SDoc

type ThetaSpec = [PredSpec]

A list of PredSpec constraints to simplify when inferring a derived instance's context. For the stock, newtype, and via deriving strategies, these will consist of SimplePredSpecs, and for DeriveAnyClass, these will consist of SubTypePredSpecs. Here is an example to illustrate the latter:

class Foo a where
  bar :: forall b. Ix b => a -> b -> String
  default bar :: forall y. (Show a, Ix y) => a -> y -> String
  bar x y = show x ++ show (range (y, y))

  baz :: Eq a => a -> a -> Bool
  default baz :: Ord a => a -> a -> Bool
  baz x y = compare x y == EQ

data Quux q = Quux deriving anyclass Foo

Then it would generate two SubTypePredSpecs, one for each method:

[ SubTypePredSpec
    { stps_ty_actual   = forall y. (Show (Quux q), Ix y) => Quux q -> y -> String
    , stps_ty_expected = forall b.                (Ix b) => Quux q -> b -> String
    , stps_ty_origin   = DerivClauseCtxt
    }
, SubTypePredSpec
    { stps_ty_actual   = Ord (Quux q) => Quux q -> Quux q -> Bool
    , stps_ty_expected = Eq  (Quux q) => Quux q -> Quux q -> Bool
    , stps_ty_origin   = DerivClauseCtxt
    }
]

(Note that the type variable q is bound by the data type Quux, and thus appears free in the stps_ty_actuals and stps_ty_expecteds.)

See Note [Gathering and simplifying constraints for DeriveAnyClass] in GHC.Tc.Deriv.Infer for an explanation of how these SubTypePredSpecs are used to compute implication constraints.

mkDirectThetaSpec :: CtOrigin -> TypeOrKind -> ThetaType -> ThetaSpec

Build a list of SimplePredSpecs, using the supplied CtOrigin and TypeOrKind values for each PredType.

substPredSpec :: HasCallStack => Subst -> PredSpec -> PredSpec

captureThetaSpecConstraints

Arguments

:: UserTypeCtxt

Used to inform error messages as to whether we are in a deriving clause or a standalone deriving declaration

-> ThetaSpec

The specs from which constraints will be created

-> TcM (TcLevel, WantedConstraints)

Capture wanted constraints from a ThetaSpec.

checkOriginativeSideConditions :: DerivInstTys -> DerivM OriginativeDerivStatus

hasStockDeriving :: Class -> Maybe StockGenFns

std_class_via_coercible :: Class -> Bool

non_coercible_class :: Class -> Bool

newDerivClsInst :: DerivSpec ThetaType -> TcM ClsInst

extendLocalInstEnv :: [ClsInst] -> TcM a -> TcM a