import GHC.Rename.Unbound

 import GHC.Tc.Types

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Errors.Types

       isNothing (lookupLocalRdrOcc lcl_env occ_name)

     record_field = case orig of

       _                   -> Nothing

 {- Note [Report candidate instances]

     -- Rule IARG from Fig 4 of the QL paper:

     go1 pos acc fun_ty

         (EValArg { ea_arg = arg, ea_ctxt = ctxt } : rest_args)

            ; (wrap, arg_ty, res_ty) <-

                 -- NB: matchActualFunTy does the rep-poly check.

                 -- For example, suppose we have f :: forall r (a::TYPE r). a -> Int

     -- Make a fresh nus for each argument in rule IVAR

     new_arg_ty (L _ arg) i

       = do { arg_nu <- newOpenFlexiFRRTyVarTy $

                -- Following matchActualFunTy, we create nu_i :: TYPE kappa_i[conc],

                -- thereby ensuring that the arguments have concrete runtime representations

                -- fixed RuntimeRep, as needed to call mkWpFun.

            ; return (result, match_wrapper <.> fun_wrap) }

       where

     go rho_ty (SynType the_ty)

       = do { wrap   <- tcSubTypePat orig GenSigCtxt the_ty rho_ty

               thing_inside (arg_results ++ res_results) (map scaledMult arg_tys ++ arg_res_mults)

        ; return (result, match_wrapper, arg_wrappers, res_wrapper) }

   where

     tc_syn_args_e :: [TcSigmaTypeFRR] -> [SyntaxOpType]

                   -> ([TcSigmaTypeFRR] -> [Mult] -> TcM a)

        ; let

            thing    = NameThing from_name

            mb_thing = Just thing

        ; (wrap2, sarg_ty, res_ty) <- matchActualFunTy herald mb_thing (1, from_ty) from_ty

        ; co <- unifyType mb_thing (hsLitType hs_lit) (scaledThing sarg_ty)

   = assertPpr (funBindPrecondition matches) (pprMatches matches) $

     do  {  -- Check that they all have the same no of arguments

           arity <- checkArgCounts matches

         ; traceTc "tcFunBindMatches 1" (ppr fun_name $$ ppr mult $$ ppr exp_ty $$ ppr arity)

         ; (wrap_fun, r)

         ; return (wrap_fun, r) }

   where

     mctxt  = mkPrefixFunRhs (noLocA fun_name) noAnn

 funBindPrecondition :: MatchGroup GhcRn (LHsExpr GhcRn) -> Bool

 funBindPrecondition (MG { mg_alts = L _ alts })

                -- Note [View patterns and polymorphism]

          -- Expression must be a function

         ; (expr_wrap1, Scaled _mult inf_arg_ty, inf_res_sigma)

             <- matchActualFunTy herald (Just . HsExprRnThing $ unLoc expr) (1,expr_ty) expr_ty

                -- See Note [View patterns and polymorphism]

 import GHC.Parser.Annotation ( LocatedN, SrcSpanAnnA )

 import GHC.Tc.Errors.Types.PromotionErr ( TermLevelUseCtxt )

 import GHC.Tc.Utils.TcType   ( TcType, TcTyCon )

 import GHC.Tc.Zonk.Monad     ( ZonkM )

   -- | In a function application.

   | FunAppCtxt !FunAppCtxtFunArg !Int

   -- | In a function call.

   -- | In the result of a function call.

   | FunResCtxt !(HsExpr GhcTc) !Int !Type !Type !Int !Int

   -- | In the declaration of a type constructor.

   CtOrigin(..), exprCtOrigin, lexprCtOrigin, matchesCtOrigin, grhssCtOrigin,

   srcCodeOriginCtOrigin,

   isVisibleOrigin, toInvisibleOrigin,

   pprCtOrigin, isGivenOrigin, isWantedWantedFunDepOrigin,

   isWantedSuperclassOrigin,

   ClsInstOrQC(..), NakedScFlag(..), NonLinearPatternReason(..),

   FRRArrowContext(..), pprFRRArrowContext,

   -- ** ExpectedFunTy FixedRuntimeRepOrigin

   -- * InstanceWhat

   InstanceWhat(..), SafeOverlapping

       Type   -- the instantiated type of the method

   | AmbiguityCheckOrigin UserTypeCtxt

   | ImplicitLiftOrigin HsImplicitLiftSplice

   | ExpansionOrigin SrcCodeOrigin -- This is due to an expansion of the original thing given by SrcCodeOrigin

 data NonLinearPatternReason

   = LazyPatternReason

   | GeneralisedPatternReason

 exprCtOrigin :: HsExpr GhcRn -> CtOrigin

 exprCtOrigin (HsVar _ (L _ (WithUserRdr _ name))) = OccurrenceOf name

 exprCtOrigin (HsOverLabel _ l)  = OverLabelOrigin l

 exprCtOrigin (ExplicitList {})    = ListOrigin

 exprCtOrigin (HsIPVar _ ip)       = IPOccOrigin ip

 exprCtOrigin (OpApp _ _ op _)     = lexprCtOrigin op

 exprCtOrigin (NegApp _ e _)       = lexprCtOrigin e

 exprCtOrigin (HsPar _ e)          = lexprCtOrigin e

 exprCtOrigin (SectionL _ _ _)     = SectionOrigin

 exprCtOrigin (SectionR _ _ _)     = SectionOrigin

 exprCtOrigin (ExplicitTuple {})   = Shouldn'tHappenOrigin "explicit tuple"

     where what :: SDoc

           what = case o of

                    OrigStmt{} -> text "a do statement"

                    OrigPat p -> text "a pattern" <+> ppr p

 pprCtOrigin (GivenSCOrigin sk d blk)

   = hang (ctoHerald <+> text "a non-linear pattern" <+> quotes (ppr pat))

        2 (pprNonLinearPatternReason reason)

 pprCtOrigin simple_origin

   = ctoHerald <+> pprCtO simple_origin

 -- | Short one-liners

 pprCtO :: HasDebugCallStack => CtOrigin -> SDoc

 pprCtO (OccurrenceOf name)   = hsep [text "a use of", quotes (ppr name)]

 pprCtO DerivClauseOrigin     = text "the 'deriving' clause of a data type declaration"

 pprCtO StandAloneDerivOrigin = text "a 'deriving' declaration"

 pprCtO DefaultOrigin         = text "a 'default' declaration"

 pprCtO MCompOrigin           = text "a statement in a monad comprehension"

 pprCtO ProcOrigin            = text "a proc expression"

 pprCtO ArrowCmdOrigin        = text "an arrow command"

 pprCtO (NonLinearPatternOrigin _ pat) = hsep [text "a non-linear pattern" <+> quotes (ppr pat)]

 pprCtO (ExpansionOrigin (OrigPat p)) = hsep [text "a pattern" <+> quotes (ppr p)]

 pprCtO (ExpansionOrigin (OrigStmt{})) = text "a do statement"

 pprNonLinearPatternReason :: HasDebugCallStack => NonLinearPatternReason -> SDoc

   --

   -- See 'ExpectedFunTyOrigin' for more details.

   | FRRExpectedFunTy

       !Int

         -- ^ argument position (1-indexed)

   = sep [ text "The body of the bind statement" ]

 pprFixedRuntimeRepContext (FRRArrow arrowContext)

   = pprFRRArrowContext arrowContext

 instance Outputable FixedRuntimeRepContext where

   ppr = pprFixedRuntimeRepContext

 --     Uses 'pprExpectedFunTyOrigin'.

 --     See 'FixedRuntimeRepContext' for the situations in which

 --     representation-polymorphism checks are performed.

 pprExpectedFunTyHerald (ExpectedFunTySyntaxOp {})

   = text "This rebindable syntax expects a function with"

 pprExpectedFunTyHerald (ExpectedFunTyViewPat {})

   = text "A view pattern expression expects"

   = sep [ text "The function" <+> quotes (ppr fun)

         , text "is applied to" ]

   = text "The equation" <> plural alts <+> text "for" <+> quotes (ppr fun) <+> hasOrHave alts

 pprExpectedFunTyHerald (ExpectedFunTyLam lam_variant expr)

   = sep [ text "The" <+> lamCaseKeyword lam_variant <+> text "expression"

                      <+> quotes (pprSetDepth (PartWay 1) (ppr expr))

                -- The pprSetDepth makes the lambda abstraction print briefly

         , text "has" ]

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

 *                                                                    *

 --

 -- See Note [Return arguments with a fixed RuntimeRep].

 matchActualFunTy

       -- ^ See Note [Herald for matchExpectedFunTys]

   -> Maybe TypedThing

       -- ^ The thing with type TcSigmaType

     go (FunTy { ft_af = af, ft_mult = w, ft_arg = arg_ty, ft_res = res_ty })

       = assert (isVisibleFunArg af) $

          ; return (idHsWrapper, Scaled w arg_ty, res_ty) }

     go ty@(TyVarTy tv)

 -- INVARIANT: the returned argument types all have a syntactically fixed RuntimeRep

 -- in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.

 -- See Note [Return arguments with a fixed RuntimeRep].

                   -> CtOrigin

                   -> Arity

                   -> TcSigmaType

 -- in the sense of Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.

 -- See Note [Return arguments with a fixed RuntimeRep].

 matchExpectedFunTys :: forall a.

                     -> UserTypeCtxt

                     -> VisArity

                     -> ExpSigmaType

                                    , ft_arg = arg_ty, ft_res = res_ty })

       = assert (isVisibleFunArg af) $

         do { let arg_pos = arity - n_req + 1   -- 1 for the first argument etc

            ; (wrap_res, result) <- check (n_req - 1)

                                          (mkCheckExpFunPatTy (Scaled mult arg_ty) : rev_pat_tys)

                                          res_ty

            ; co <- unifyType Nothing (mkScaledFunTys more_arg_tys res_ty) fun_ty

            ; return (mkWpCastN co, result) }

 new_infer_arg_ty herald arg_pos -- position for error messages only

   = do { mult     <- newFlexiTyVarTy multiplicityTy

        ; return (mkScaled mult inf_hole) }

 new_check_arg_ty herald arg_pos -- Position for error messages only, 1 for first arg

   = do { mult   <- newFlexiTyVarTy multiplicityTy

        ; return (mkScaled mult arg_ty) }

             -> (VisArity, TcType)

             -> TidyEnv -> ZonkM (TidyEnv, ErrCtxtMsg)

 -- See Note [Reporting application arity errors]