rnInjectivityAnn tvBndrs (L _ (TyVarSig _ resTv))

                  (L srcSpan (InjectivityAnn x injFrom injTo))

  = do

              bindLocalNames (maybeToList (hsLTyVarName resTv)) $

              -- The return type variable scopes over the injectivity annotation

              -- e.g.   type family F a = (r::*) | r -> a

    -- if renaming of type variables ended with errors (eg. there were

    -- not-in-scope variables) don't check the validity of injectivity

    -- annotation. This gives better error messages.

         addErrAt (getLocA injFrom) $

           TcRnIncorrectTyVarOnLhsOfInjCond resName injFrom

       do { let errorVars = Set.toList rhsValid

          ; addErrAt (locA srcSpan) $

               TcRnUnknownTyVarsOnRhsOfInjCond errorVars } } }

 -- this time we expect "result" to be reported not in scope by rnLTyVar.

 rnInjectivityAnn _ _ (L srcSpan (InjectivityAnn x injFrom injTo)) =

    setSrcSpanA srcSpan $ do

      injFrom' <- rnLTyVar injFrom

      injTo'   <- mapM rnLTyVar injTo

      return $ L srcSpan (InjectivityAnn x (fmap greName injFrom') (fmap (fmap greName) injTo'))

                             , cec_expr_holes         = expr_holes

                             , cec_type_holes         = type_holes

                             , cec_out_of_scope_holes = out_of_scope_holes

                             , cec_warn_redundant     = warn_redundant

                             , cec_expand_syns        = exp_syns

                             , cec_binds              = binds_var }

 This is done by maybeSwitchOffDefer.  It's also useful in one other

 place: see Note [Wrapping failing kind equalities] in GHC.Tc.Solver.

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

 evidence bindings (as usual).  It's used when more important errors have occurred

 (SLIE0)

     group in `reportWanteds`

   To see this, look at the plumbing of cec suppress in `reportWanteds`

   wanteds /anywhere/ in the tree, via `insolubleWC`.  That means we'll suppress all

   less-important errors in favour of the more important (insolbule) ones

 (SLIE2) But we need to take care: flags can turn errors into warnings, and we

   don't want those warnings to suppress subsequent errors (including

   suppressing the essential addTcEvBind for them: #15152). So in

   /actually/ produced; if not, we don't switch on suppression.

   A consequence is that warnings never suppress warnings, so turning an

   previously suppressed.   (e.g. partial-sigs/should_fail/T14584)

 (SLIE3) There is a tricky interaction between

    * `ei_suppress` (a local, per-error-item flag),

      see Note [ei_suppress: suppressing confusing errors]

    arising from a superclass constraint of an unsolved dictionary `[W] d::C a`.

    This constraint will have ei_suppress=True. We must not suppress that less-insoluble

    constraint `[W] d::C a`, lest we get no error at all (#18851).

 There are wrinkles

    How can it happen that there are /all/ errors are suppressed?

    * See test T18851 for an example of how it is (just, barely) possible for the

      /only/ errors to be superclass-of-Wanted constraints.

    * Similarly #27731, which also involves a superclass-of-Wanted:

           class (a ~ F b) => Ren a b

      If we have a [W] Ren a b, we'll emit the superclass [W] a ~ F b, which will

      rewrite the original class constraint to [W] Ren (F b) b.  Now we have two

      constraints: one has a non-empty rewriter set (SEC1) and one is a superclass of

      a Wanted (SEC2).

    * Also see Wrinkle (PER2) in Note [Prioritise Wanteds with empty

      CoHoleSet] in GHC.Tc.Types.Constraint.

                   , cec_encl     = implic' : cec_encl ctxt

 -- NO LONGER NEEDED

                         -- Suppress inessential errors if there

                         -- are insolubles anywhere in the

                         -- tree rooted here, or we've come across

 reportBadTelescope _ _ skol_info skols

   = pprPanic "reportBadTelescope" (ppr skol_info $$ ppr skols)

 -- | Makes an error item from a constraint, calculating whether or not the item

 -- should be suppressed. See Note [Wanteds rewrite Wanteds: rewriter-sets]

 -- in GHC.Tc.Types.Constraint. Returns Nothing if we should just ignore

                             , ei_suppress  = suppressCtError ev }}

 -- | Actually report this 'ErrorItem'.

 -- | Should we completely ignore this constraint in error reporting?

 -- It *must* be the case that any constraint for which this returns True

   | otherwise

   = do { let tidy_cts  = bagToList (mapBag (tidyCt env)           simples)

              tidy_errs = bagToList (mapBag (tidyDelayedError env) errs)

                                          , text "tidy_cts   =" <+> ppr tidy_cts

        ; let (out_of_scope, other_holes, not_conc_errs, mult_co_errs)

                 = partition_errors tidy_errs

          -- First, deal with any out-of-scope errors:

        -- Don't suppress holes or concreteness errors, ever

        ; reportHoles ctxt tidy_items other_holes

        -- or   Int ~ t a  (AppTy on one side)

        --

        -- First visible ones, then invisible ones; but all serious

              (vis_items, invis_items)

                 = partition (isVisibleOrigin . errorItemOrigin) tidy_items

                tryReporters ctxt suppress_insols serious_reporters vis_items

                tryReporters ctxt suppress_invis serious_reporters invis_items

        -- to suppress further errors if we have found any serious errors locally

                              || suppress_invis

        ; leftovers <- tryReporters ctxt suppress_rest less_serious_reporters $

                       (vis_items1 ++ invis_items1)

        ; massertPpr (null leftovers)

            (text "The following unsolved Wanted constraints \

                  \have not been reported to the user:"

            $$ ppr leftovers)

        }

  where

     env       = cec_tidy ctxt

           DE_Multiplicity mult_co loc

             -> (es1, es2, es3, (mult_co, loc):es4)

     --     (i.e. by an insoluble somewhere else in the tree)

     serious_reporters

       = [ -- We put implicit lifting errors first, because are solid errors

             -> [ErrorItem]  -- Other (tidied) constraints

             -> [Hole]       -- Holes to report

             -> TcM ()

 reportHoles ctxt tidy_items holes

   = do

       diag_opts <- initDiagOpts <$> getDynFlags

                 return (tidy_env',  extendNameEnv name_env name tidy_ty)

 reportNotConcreteErrs :: SolverReportErrCtxt -> [NotConcreteError] -> TcM ()

 reportNotConcreteErrs _ [] = return ()

 reportNotConcreteErrs ctxt errs@(err0:_)

   = do { msg <- mkErrorReport (ctLocEnv (nce_loc err0)) diag (Just ctxt) [] []

        ; err <- mk_err items

        ; traceTc "About to maybeReportErr" $

          vcat [ text "Constraint:"             <+> ppr items

               , text "cec_defer_type_errors =" <+> ppr (cec_defer_type_errors ctxt) ]

        ; maybeReportError ctxt items err

 --    T @X1 T1 ~ T @X2 T2   gives two insolubles: X1~X2 and T1~T2 (KindVType, T17380, T22332b)

 --

 --     | any ei_insoluble items

      = True   -- Some earlier error has occurred, so suppress this diagnostic

      | all ei_suppress items

 tryReporters :: SolverReportErrCtxt

              -> Bool              -- Suppress errors if this is True

              -> [ReporterSpec]

              -> [ErrorItem]

              -> TcM [ErrorItem]

        ; traceTc "tryReporters }" (ppr items')

        ; return items' }

   where

     go []     items = return items

     go (r:rs) items = do { items' <- tryReporter ctxt_w_suppress r items

                          ; go rs items' }

 {- Note [Always warn with -fdefer-type-errors]

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

 When -fdefer-type-errors is on we warn about *all* type errors, even

 would get errors without -fdefer-type-errors, but if we suppress any of

 them you might get a runtime error that wasn't warned about at compile

 time.

 {- Note [Constructing Hole Errors]

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

 There are two cases to consider:

            , cec_out_of_scope_holes = osh

            , cec_warn_redundant     = wr

            , cec_expand_syns        = es

     = text "CEC" <+> braces (vcat

          [ text "cec_binds"              <+> equals <+> ppr bvar

          , text "cec_defer_type_errors"  <+> equals <+> ppr dte

          , text "cec_out_of_scope_holes" <+> equals <+> ppr osh

          , text "cec_warn_redundant"     <+> equals <+> ppr wr

          , text "cec_expand_syns"        <+> equals <+> ppr es

 {- *********************************************************************

 *                                                                      *

           , cec_warn_redundant :: Bool    -- ^ True <=> -Wredundant-constraints

           , cec_expand_syns    :: Bool    -- ^ True <=> -fprint-expanded-synonyms

                                     --            so create bindings if need be, but

                                     --            don't issue any more errors/warnings

       }

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

        , ei_insoluble :: Bool   -- True if the constraint is definitely insoluble

                                 -- Cache of `insolubleCt`

        }

 instance Outputable ErrorItem where

              home_fie' = extendFamInstEnv home_fie fam_inst

            -- Check for conflicting instance decls and injectivity violations

          do { checkForConflicts            inst_envs fam_inst

             ; checkForInjectivityConflicts inst_envs fam_inst

             ; checkInjectiveEquation       fam_inst

             }

          else

 {-

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

 tryTypeClassDefaulting :: WantedConstraints -> TcS WantedConstraints

 tryTypeClassDefaulting wc

   = return wc

   | otherwise  -- See Note [When to do type-class defaulting]

   = do { something_happened <- applyDefaultingRules wc

     float_implic :: Bool -> TcTyCoVarSet -> Implication

                  -> ApproxWC -> ApproxWC

       where

     float_ct :: Bool -> TcTyCoVarSet -> Ct

              -> ApproxWC -> ApproxWC

     float_ct encl_eqs skol_tvs ct acc@(quant, no_quant)

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

   -- * Shared error message stuff: renamer and typechecker

   recoverM, mapAndRecoverM, mapAndReportM, foldAndRecoverM,

   attemptM, tryTc,

   tryTcDiscardingErrs,

   tryTcDiscardingErrs',

   checkNoErrs, whenNoErrs,

 --      If so, it fails too.

 -- Regardless, any errors generated by m are propagated to the enclosing context.

 checkNoErrs main

         ; return res }

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

        ; return (res, msgs) }

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

 -- If m fails,

 --         insoluble constraints

 --

 -- If m succeeds with result r,

 --

 -- Regardless of success or failure,

 --   propagate any errors/warnings generated by m

   = do { ((mb_res, lie), msgs) <- capture_messages    $

                                   capture_constraints $

                                   tcTryM thing_inside

            Just res -> do { emitConstraints lie

                           ; let errs_found = errorsFound msgs

                                           || insolubleWC lie

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

 tryCaptureConstraints :: TcM a -> TcM (Maybe a, WantedConstraints)