{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

\section[TcBinds]{TcBinds}
-}

{-# LANGUAGE CPP, RankNTypes, ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ViewPatterns #-}

module TcBinds ( tcLocalBinds, tcTopBinds, tcValBinds,
                 tcHsBootSigs, tcPolyCheck,
                 addTypecheckedBinds,
                 chooseInferredQuantifiers,
                 badBootDeclErr ) where

import GhcPrelude

import {-# SOURCE #-} TcMatches ( tcGRHSsPat, tcMatchesFun )
import {-# SOURCE #-} TcExpr  ( tcMonoExpr )
import {-# SOURCE #-} TcPatSyn ( tcPatSynDecl, tcPatSynBuilderBind )
import CoreSyn (Tickish (..))
import CostCentre (mkUserCC, CCFlavour(DeclCC))
import DynFlags
import FastString
import HsSyn
import HscTypes( isHsBootOrSig )
import TcSigs
import TcRnMonad
import TcEnv
import TcUnify
import TcSimplify
import TcEvidence
import TcHsType
import TcPat
import TcMType
import FamInstEnv( normaliseType )
import FamInst( tcGetFamInstEnvs )
import TyCon
import TcType
import Type( mkStrLitTy, tidyOpenType, splitTyConApp_maybe, mkCastTy)
import TysPrim
import TysWiredIn( mkBoxedTupleTy )
import Id
import Var
import VarSet
import VarEnv( TidyEnv )
import Module
import Name
import NameSet
import NameEnv
import SrcLoc
import Bag
import ErrUtils
import Digraph
import Maybes
import Util
import BasicTypes
import Outputable
import PrelNames( ipClassName )
import TcValidity (checkValidType)
import UniqFM
import UniqSet
import qualified GHC.LanguageExtensions as LangExt
import ConLike

import Control.Monad

#include "HsVersions.h"

{- *********************************************************************
*                                                                      *
               A useful helper function
*                                                                      *
********************************************************************* -}

addTypecheckedBinds :: TcGblEnv -> [LHsBinds GhcTc] -> TcGblEnv
addTypecheckedBinds :: TcGblEnv -> [LHsBinds GhcTc] -> TcGblEnv
addTypecheckedBinds tcg_env :: TcGblEnv
tcg_env binds :: [LHsBinds GhcTc]
binds
  | HscSource -> Bool
isHsBootOrSig (TcGblEnv -> HscSource
tcg_src TcGblEnv
tcg_env) = TcGblEnv
tcg_env
    -- Do not add the code for record-selector bindings
    -- when compiling hs-boot files
  | Bool
otherwise = TcGblEnv
tcg_env { tcg_binds :: LHsBinds GhcTc
tcg_binds = (LHsBinds GhcTc -> LHsBinds GhcTc -> LHsBinds GhcTc)
-> LHsBinds GhcTc -> [LHsBinds GhcTc] -> LHsBinds GhcTc
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr LHsBinds GhcTc -> LHsBinds GhcTc -> LHsBinds GhcTc
forall a. Bag a -> Bag a -> Bag a
unionBags
                                            (TcGblEnv -> LHsBinds GhcTc
tcg_binds TcGblEnv
tcg_env)
                                            [LHsBinds GhcTc]
binds }

{-
************************************************************************
*                                                                      *
\subsection{Type-checking bindings}
*                                                                      *
************************************************************************

@tcBindsAndThen@ typechecks a @HsBinds@.  The "and then" part is because
it needs to know something about the {\em usage} of the things bound,
so that it can create specialisations of them.  So @tcBindsAndThen@
takes a function which, given an extended environment, E, typechecks
the scope of the bindings returning a typechecked thing and (most
important) an LIE.  It is this LIE which is then used as the basis for
specialising the things bound.

@tcBindsAndThen@ also takes a "combiner" which glues together the
bindings and the "thing" to make a new "thing".

The real work is done by @tcBindWithSigsAndThen@.

Recursive and non-recursive binds are handled in essentially the same
way: because of uniques there are no scoping issues left.  The only
difference is that non-recursive bindings can bind primitive values.

Even for non-recursive binding groups we add typings for each binder
to the LVE for the following reason.  When each individual binding is
checked the type of its LHS is unified with that of its RHS; and
type-checking the LHS of course requires that the binder is in scope.

At the top-level the LIE is sure to contain nothing but constant
dictionaries, which we resolve at the module level.

Note [Polymorphic recursion]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The game plan for polymorphic recursion in the code above is

        * Bind any variable for which we have a type signature
          to an Id with a polymorphic type.  Then when type-checking
          the RHSs we'll make a full polymorphic call.

This fine, but if you aren't a bit careful you end up with a horrendous
amount of partial application and (worse) a huge space leak. For example:

        f :: Eq a => [a] -> [a]
        f xs = ...f...

If we don't take care, after typechecking we get

        f = /\a -> \d::Eq a -> let f' = f a d
                               in
                               \ys:[a] -> ...f'...

Notice the stupid construction of (f a d), which is of course
identical to the function we're executing.  In this case, the
polymorphic recursion isn't being used (but that's a very common case).
This can lead to a massive space leak, from the following top-level defn
(post-typechecking)

        ff :: [Int] -> [Int]
        ff = f Int dEqInt

Now (f dEqInt) evaluates to a lambda that has f' as a free variable; but
f' is another thunk which evaluates to the same thing... and you end
up with a chain of identical values all hung onto by the CAF ff.

        ff = f Int dEqInt

           = let f' = f Int dEqInt in \ys. ...f'...

           = let f' = let f' = f Int dEqInt in \ys. ...f'...
                      in \ys. ...f'...

Etc.

NOTE: a bit of arity anaysis would push the (f a d) inside the (\ys...),
which would make the space leak go away in this case

Solution: when typechecking the RHSs we always have in hand the
*monomorphic* Ids for each binding.  So we just need to make sure that
if (Method f a d) shows up in the constraints emerging from (...f...)
we just use the monomorphic Id.  We achieve this by adding monomorphic Ids
to the "givens" when simplifying constraints.  That's what the "lies_avail"
is doing.

Then we get

        f = /\a -> \d::Eq a -> letrec
                                 fm = \ys:[a] -> ...fm...
                               in
                               fm
-}

tcTopBinds :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn]
           -> TcM (TcGblEnv, TcLclEnv)
-- The TcGblEnv contains the new tcg_binds and tcg_spects
-- The TcLclEnv has an extended type envt for the new bindings
tcTopBinds :: [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn] -> TcM (TcGblEnv, TcLclEnv)
tcTopBinds binds :: [(RecFlag, LHsBinds GhcRn)]
binds sigs :: [LSig GhcRn]
sigs
  = do  { -- Pattern synonym bindings populate the global environment
          (binds' :: [(RecFlag, LHsBinds GhcTc)]
binds', (tcg_env :: TcGblEnv
tcg_env, tcl_env :: TcLclEnv
tcl_env)) <- TopLevelFlag
-> [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn]
-> TcM (TcGblEnv, TcLclEnv)
-> TcM ([(RecFlag, LHsBinds GhcTc)], (TcGblEnv, TcLclEnv))
forall thing.
TopLevelFlag
-> [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcValBinds TopLevelFlag
TopLevel [(RecFlag, LHsBinds GhcRn)]
binds [LSig GhcRn]
sigs (TcM (TcGblEnv, TcLclEnv)
 -> TcM ([(RecFlag, LHsBinds GhcTc)], (TcGblEnv, TcLclEnv)))
-> TcM (TcGblEnv, TcLclEnv)
-> TcM ([(RecFlag, LHsBinds GhcTc)], (TcGblEnv, TcLclEnv))
forall a b. (a -> b) -> a -> b
$
            do { TcGblEnv
gbl <- TcRnIf TcGblEnv TcLclEnv TcGblEnv
forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
               ; TcLclEnv
lcl <- TcRnIf TcGblEnv TcLclEnv TcLclEnv
forall gbl lcl. TcRnIf gbl lcl lcl
getLclEnv
               ; (TcGblEnv, TcLclEnv) -> TcM (TcGblEnv, TcLclEnv)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcGblEnv
gbl, TcLclEnv
lcl) }
        ; [LTcSpecPrag]
specs <- [LSig GhcRn] -> TcM [LTcSpecPrag]
tcImpPrags [LSig GhcRn]
sigs   -- SPECIALISE prags for imported Ids

        ; [CompleteMatch]
complete_matches <- (TcGblEnv, TcLclEnv)
-> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
-> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
forall gbl' lcl' a gbl lcl.
(gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a
setEnvs (TcGblEnv
tcg_env, TcLclEnv
tcl_env) (TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
 -> TcRnIf TcGblEnv TcLclEnv [CompleteMatch])
-> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
-> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
forall a b. (a -> b) -> a -> b
$ [LSig GhcRn] -> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
tcCompleteSigs [LSig GhcRn]
sigs
        ; String -> SDoc -> TcRn ()
traceTc "complete_matches" ([(RecFlag, LHsBinds GhcRn)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(RecFlag, LHsBinds GhcRn)]
binds SDoc -> SDoc -> SDoc
$$ [LSig GhcRn] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [LSig GhcRn]
sigs)
        ; String -> SDoc -> TcRn ()
traceTc "complete_matches" ([CompleteMatch] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [CompleteMatch]
complete_matches)

        ; let { tcg_env' :: TcGblEnv
tcg_env' = TcGblEnv
tcg_env { tcg_imp_specs :: [LTcSpecPrag]
tcg_imp_specs
                                      = [LTcSpecPrag]
specs [LTcSpecPrag] -> [LTcSpecPrag] -> [LTcSpecPrag]
forall a. [a] -> [a] -> [a]
++ TcGblEnv -> [LTcSpecPrag]
tcg_imp_specs TcGblEnv
tcg_env
                                   , tcg_complete_matches :: [CompleteMatch]
tcg_complete_matches
                                      = [CompleteMatch]
complete_matches
                                          [CompleteMatch] -> [CompleteMatch] -> [CompleteMatch]
forall a. [a] -> [a] -> [a]
++ TcGblEnv -> [CompleteMatch]
tcg_complete_matches TcGblEnv
tcg_env }
                           TcGblEnv -> [LHsBinds GhcTc] -> TcGblEnv
`addTypecheckedBinds` ((RecFlag, LHsBinds GhcTc) -> LHsBinds GhcTc)
-> [(RecFlag, LHsBinds GhcTc)] -> [LHsBinds GhcTc]
forall a b. (a -> b) -> [a] -> [b]
map (RecFlag, LHsBinds GhcTc) -> LHsBinds GhcTc
forall a b. (a, b) -> b
snd [(RecFlag, LHsBinds GhcTc)]
binds' }

        ; (TcGblEnv, TcLclEnv) -> TcM (TcGblEnv, TcLclEnv)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcGblEnv
tcg_env', TcLclEnv
tcl_env) }
        -- The top level bindings are flattened into a giant
        -- implicitly-mutually-recursive LHsBinds


-- Note [Typechecking Complete Matches]
-- Much like when a user bundled a pattern synonym, the result types of
-- all the constructors in the match pragma must be consistent.
--
-- If we allowed pragmas with inconsistent types then it would be
-- impossible to ever match every constructor in the list and so
-- the pragma would be useless.





-- This is only used in `tcCompleteSig`. We fold over all the conlikes,
-- this accumulator keeps track of the first `ConLike` with a concrete
-- return type. After fixing the return type, all other constructors with
-- a fixed return type must agree with this.
--
-- The fields of `Fixed` cache the first conlike and its return type so
-- that that we can compare all the other conlikes to it. The conlike is
-- stored for error messages.
--
-- `Nothing` in the case that the type is fixed by a type signature
data CompleteSigType = AcceptAny | Fixed (Maybe ConLike) TyCon

tcCompleteSigs  :: [LSig GhcRn] -> TcM [CompleteMatch]
tcCompleteSigs :: [LSig GhcRn] -> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
tcCompleteSigs sigs :: [LSig GhcRn]
sigs =
  let
      doOne :: Sig GhcRn -> TcM (Maybe CompleteMatch)
      doOne :: Sig GhcRn -> TcM (Maybe CompleteMatch)
doOne c :: Sig GhcRn
c@(CompleteMatchSig _ _ lns :: Located [Located (IdP GhcRn)]
lns mtc :: Maybe (Located (IdP GhcRn))
mtc)
        = (CompleteMatch -> Maybe CompleteMatch)
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
-> TcM (Maybe CompleteMatch)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CompleteMatch -> Maybe CompleteMatch
forall a. a -> Maybe a
Just (IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
 -> TcM (Maybe CompleteMatch))
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
-> TcM (Maybe CompleteMatch)
forall a b. (a -> b) -> a -> b
$ do
           SDoc
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (String -> SDoc
text "In" SDoc -> SDoc -> SDoc
<+> Sig GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr Sig GhcRn
c) (IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
 -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch)
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
-> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall a b. (a -> b) -> a -> b
$
            case Maybe (Located (IdP GhcRn))
mtc of
              Nothing -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
infer_complete_match
              Just tc :: Located (IdP GhcRn)
tc -> Located Name -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
check_complete_match Located Name
Located (IdP GhcRn)
tc
        where

          checkCLTypes :: CompleteSigType
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
checkCLTypes acc :: CompleteSigType
acc = ((CompleteSigType, [ConLike])
 -> Located Name
 -> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike]))
-> (CompleteSigType, [ConLike])
-> [Located Name]
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m b
foldM (CompleteSigType, [ConLike])
-> Located Name
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
checkCLType (CompleteSigType
acc, []) (Located [Located Name] -> SrcSpanLess (Located [Located Name])
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located [Located Name]
Located [Located (IdP GhcRn)]
lns)

          infer_complete_match :: IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
infer_complete_match = do
            (res :: CompleteSigType
res, cls :: [ConLike]
cls) <- CompleteSigType
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
checkCLTypes CompleteSigType
AcceptAny
            case CompleteSigType
res of
              AcceptAny -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall a. SDoc -> TcM a
failWithTc SDoc
ambiguousError
              Fixed _ tc :: TyCon
tc  -> CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall (m :: * -> *) a. Monad m => a -> m a
return (CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch)
-> CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall a b. (a -> b) -> a -> b
$ [ConLike] -> TyCon -> CompleteMatch
mkMatch [ConLike]
cls TyCon
tc

          check_complete_match :: Located Name -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
check_complete_match tc_name :: Located Name
tc_name = do
            TyCon
ty_con <- Located Name -> TcM TyCon
tcLookupLocatedTyCon Located Name
tc_name
            (_, cls :: [ConLike]
cls) <- CompleteSigType
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
checkCLTypes (Maybe ConLike -> TyCon -> CompleteSigType
Fixed Maybe ConLike
forall a. Maybe a
Nothing TyCon
ty_con)
            CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall (m :: * -> *) a. Monad m => a -> m a
return (CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch)
-> CompleteMatch -> IOEnv (Env TcGblEnv TcLclEnv) CompleteMatch
forall a b. (a -> b) -> a -> b
$ [ConLike] -> TyCon -> CompleteMatch
mkMatch [ConLike]
cls TyCon
ty_con

          mkMatch :: [ConLike] -> TyCon -> CompleteMatch
          mkMatch :: [ConLike] -> TyCon -> CompleteMatch
mkMatch cls :: [ConLike]
cls ty_con :: TyCon
ty_con = CompleteMatch :: [Name] -> Name -> CompleteMatch
CompleteMatch {
            completeMatchConLikes :: [Name]
completeMatchConLikes = (ConLike -> Name) -> [ConLike] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map ConLike -> Name
conLikeName [ConLike]
cls,
            completeMatchTyCon :: Name
completeMatchTyCon = TyCon -> Name
tyConName TyCon
ty_con
            }
      doOne _ = Maybe CompleteMatch -> TcM (Maybe CompleteMatch)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe CompleteMatch
forall a. Maybe a
Nothing

      ambiguousError :: SDoc
      ambiguousError :: SDoc
ambiguousError =
        String -> SDoc
text "A type signature must be provided for a set of polymorphic"
          SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "pattern synonyms."


      -- See note [Typechecking Complete Matches]
      checkCLType :: (CompleteSigType, [ConLike]) -> Located Name
                  -> TcM (CompleteSigType, [ConLike])
      checkCLType :: (CompleteSigType, [ConLike])
-> Located Name
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
checkCLType (cst :: CompleteSigType
cst, cs :: [ConLike]
cs) n :: Located Name
n = do
        ConLike
cl <- (SrcSpanLess (Located Name) -> TcM ConLike)
-> Located Name -> TcM ConLike
forall a b. HasSrcSpan a => (SrcSpanLess a -> TcM b) -> a -> TcM b
addLocM Name -> TcM ConLike
SrcSpanLess (Located Name) -> TcM ConLike
tcLookupConLike Located Name
n
        let   (_,_,_,_,_,_, res_ty :: Type
res_ty) = ConLike
-> ([TyVar], [TyVar], [EqSpec], ThetaType, ThetaType, ThetaType,
    Type)
conLikeFullSig ConLike
cl
              res_ty_con :: Maybe TyCon
res_ty_con = (TyCon, ThetaType) -> TyCon
forall a b. (a, b) -> a
fst ((TyCon, ThetaType) -> TyCon)
-> Maybe (TyCon, ThetaType) -> Maybe TyCon
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> HasDebugCallStack => Type -> Maybe (TyCon, ThetaType)
Type -> Maybe (TyCon, ThetaType)
splitTyConApp_maybe Type
res_ty
        case (CompleteSigType
cst, Maybe TyCon
res_ty_con) of
          (AcceptAny, Nothing) -> (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall (m :: * -> *) a. Monad m => a -> m a
return (CompleteSigType
AcceptAny, ConLike
clConLike -> [ConLike] -> [ConLike]
forall a. a -> [a] -> [a]
:[ConLike]
cs)
          (AcceptAny, Just tc :: TyCon
tc) -> (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ConLike -> TyCon -> CompleteSigType
Fixed (ConLike -> Maybe ConLike
forall a. a -> Maybe a
Just ConLike
cl) TyCon
tc, ConLike
clConLike -> [ConLike] -> [ConLike]
forall a. a -> [a] -> [a]
:[ConLike]
cs)
          (Fixed mfcl :: Maybe ConLike
mfcl tc :: TyCon
tc, Nothing)  -> (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ConLike -> TyCon -> CompleteSigType
Fixed Maybe ConLike
mfcl TyCon
tc, ConLike
clConLike -> [ConLike] -> [ConLike]
forall a. a -> [a] -> [a]
:[ConLike]
cs)
          (Fixed mfcl :: Maybe ConLike
mfcl tc :: TyCon
tc, Just tc' :: TyCon
tc') ->
            if TyCon
tc TyCon -> TyCon -> Bool
forall a. Eq a => a -> a -> Bool
== TyCon
tc'
              then (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe ConLike -> TyCon -> CompleteSigType
Fixed Maybe ConLike
mfcl TyCon
tc, ConLike
clConLike -> [ConLike] -> [ConLike]
forall a. a -> [a] -> [a]
:[ConLike]
cs)
              else case Maybe ConLike
mfcl of
                     Nothing ->
                      SDoc
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (String -> SDoc
text "In" SDoc -> SDoc -> SDoc
<+> ConLike -> SDoc
forall a. Outputable a => a -> SDoc
ppr ConLike
cl) (IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
 -> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike]))
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
-> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall a b. (a -> b) -> a -> b
$
                        SDoc -> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall a. SDoc -> TcM a
failWithTc SDoc
typeSigErrMsg
                     Just cl :: ConLike
cl -> SDoc -> IOEnv (Env TcGblEnv TcLclEnv) (CompleteSigType, [ConLike])
forall a. SDoc -> TcM a
failWithTc (ConLike -> SDoc
errMsg ConLike
cl)
             where
              typeSigErrMsg :: SDoc
              typeSigErrMsg :: SDoc
typeSigErrMsg =
                String -> SDoc
text "Couldn't match expected type"
                      SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc)
                      SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "with"
                      SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc')

              errMsg :: ConLike -> SDoc
              errMsg :: ConLike -> SDoc
errMsg fcl :: ConLike
fcl =
                String -> SDoc
text "Cannot form a group of complete patterns from patterns"
                  SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (ConLike -> SDoc
forall a. Outputable a => a -> SDoc
ppr ConLike
fcl) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "and" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (ConLike -> SDoc
forall a. Outputable a => a -> SDoc
ppr ConLike
cl)
                  SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "as they match different type constructors"
                  SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens (SDoc -> SDoc
quotes (TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc)
                               SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "resp."
                               SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (TyCon -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyCon
tc'))
  in  (LSig GhcRn -> TcM (Maybe CompleteMatch))
-> [LSig GhcRn] -> TcRnIf TcGblEnv TcLclEnv [CompleteMatch]
forall (m :: * -> *) a b.
Applicative m =>
(a -> m (Maybe b)) -> [a] -> m [b]
mapMaybeM ((SrcSpanLess (LSig GhcRn) -> TcM (Maybe CompleteMatch))
-> LSig GhcRn -> TcM (Maybe CompleteMatch)
forall a b. HasSrcSpan a => (SrcSpanLess a -> TcM b) -> a -> TcM b
addLocM SrcSpanLess (LSig GhcRn) -> TcM (Maybe CompleteMatch)
Sig GhcRn -> TcM (Maybe CompleteMatch)
doOne) [LSig GhcRn]
sigs

tcHsBootSigs :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM [Id]
-- A hs-boot file has only one BindGroup, and it only has type
-- signatures in it.  The renamer checked all this
tcHsBootSigs :: [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn] -> TcM [TyVar]
tcHsBootSigs binds :: [(RecFlag, LHsBinds GhcRn)]
binds sigs :: [LSig GhcRn]
sigs
  = do  { Bool -> SDoc -> TcRn ()
checkTc ([(RecFlag, LHsBinds GhcRn)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(RecFlag, LHsBinds GhcRn)]
binds) SDoc
badBootDeclErr
        ; [[TyVar]] -> [TyVar]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[TyVar]] -> [TyVar])
-> IOEnv (Env TcGblEnv TcLclEnv) [[TyVar]] -> TcM [TyVar]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LSig GhcRn -> TcM [TyVar])
-> [LSig GhcRn] -> IOEnv (Env TcGblEnv TcLclEnv) [[TyVar]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((SrcSpanLess (LSig GhcRn) -> TcM [TyVar])
-> LSig GhcRn -> TcM [TyVar]
forall a b. HasSrcSpan a => (SrcSpanLess a -> TcM b) -> a -> TcM b
addLocM SrcSpanLess (LSig GhcRn) -> TcM [TyVar]
Sig GhcRn -> TcM [TyVar]
tc_boot_sig) ((LSig GhcRn -> Bool) -> [LSig GhcRn] -> [LSig GhcRn]
forall a. (a -> Bool) -> [a] -> [a]
filter LSig GhcRn -> Bool
forall name. LSig name -> Bool
isTypeLSig [LSig GhcRn]
sigs) }
  where
    tc_boot_sig :: Sig GhcRn -> TcM [TyVar]
tc_boot_sig (TypeSig _ lnames :: [Located (IdP GhcRn)]
lnames hs_ty :: LHsSigWcType GhcRn
hs_ty) = (Located Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar)
-> [Located Name] -> TcM [TyVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Located Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
f [Located Name]
[Located (IdP GhcRn)]
lnames
      where
        f :: Located Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
f (Located Name -> Located (SrcSpanLess (Located Name))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ name :: SrcSpanLess (Located Name)
name)
          = do { Type
sigma_ty <- UserTypeCtxt -> LHsSigWcType GhcRn -> TcM Type
tcHsSigWcType (Name -> Bool -> UserTypeCtxt
FunSigCtxt Name
SrcSpanLess (Located Name)
name Bool
False) LHsSigWcType GhcRn
hs_ty
               ; TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Type -> TyVar
mkVanillaGlobal Name
SrcSpanLess (Located Name)
name Type
sigma_ty) }
        -- Notice that we make GlobalIds, not LocalIds
    tc_boot_sig s :: Sig GhcRn
s = String -> SDoc -> TcM [TyVar]
forall a. HasCallStack => String -> SDoc -> a
pprPanic "tcHsBootSigs/tc_boot_sig" (Sig GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr Sig GhcRn
s)

badBootDeclErr :: MsgDoc
badBootDeclErr :: SDoc
badBootDeclErr = String -> SDoc
text "Illegal declarations in an hs-boot file"

------------------------
tcLocalBinds :: HsLocalBinds GhcRn -> TcM thing
             -> TcM (HsLocalBinds GhcTcId, thing)

tcLocalBinds :: HsLocalBinds GhcRn -> TcM thing -> TcM (HsLocalBinds GhcTc, thing)
tcLocalBinds (EmptyLocalBinds x :: XEmptyLocalBinds GhcRn GhcRn
x) thing_inside :: TcM thing
thing_inside
  = do  { thing
thing <- TcM thing
thing_inside
        ; (HsLocalBinds GhcTc, thing) -> TcM (HsLocalBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (XEmptyLocalBinds GhcTc GhcTc -> HsLocalBinds GhcTc
forall idL idR. XEmptyLocalBinds idL idR -> HsLocalBindsLR idL idR
EmptyLocalBinds XEmptyLocalBinds GhcRn GhcRn
XEmptyLocalBinds GhcTc GhcTc
x, thing
thing) }

tcLocalBinds (HsValBinds x :: XHsValBinds GhcRn GhcRn
x (XValBindsLR (NValBinds binds sigs))) thing_inside :: TcM thing
thing_inside
  = do  { (binds' :: [(RecFlag, LHsBinds GhcTc)]
binds', thing :: thing
thing) <- TopLevelFlag
-> [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall thing.
TopLevelFlag
-> [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcValBinds TopLevelFlag
NotTopLevel [(RecFlag, LHsBinds GhcRn)]
binds [LSig GhcRn]
sigs TcM thing
thing_inside
        ; (HsLocalBinds GhcTc, thing) -> TcM (HsLocalBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (XHsValBinds GhcTc GhcTc
-> HsValBindsLR GhcTc GhcTc -> HsLocalBinds GhcTc
forall idL idR.
XHsValBinds idL idR
-> HsValBindsLR idL idR -> HsLocalBindsLR idL idR
HsValBinds XHsValBinds GhcRn GhcRn
XHsValBinds GhcTc GhcTc
x (XXValBindsLR GhcTc GhcTc -> HsValBindsLR GhcTc GhcTc
forall idL idR. XXValBindsLR idL idR -> HsValBindsLR idL idR
XValBindsLR ([(RecFlag, LHsBinds GhcTc)] -> [LSig GhcRn] -> NHsValBindsLR GhcTc
forall idL.
[(RecFlag, LHsBinds idL)] -> [LSig GhcRn] -> NHsValBindsLR idL
NValBinds [(RecFlag, LHsBinds GhcTc)]
binds' [LSig GhcRn]
sigs)), thing
thing) }
tcLocalBinds (HsValBinds _ (ValBinds {})) _ = String -> TcM (HsLocalBinds GhcTc, thing)
forall a. String -> a
panic "tcLocalBinds"

tcLocalBinds (HsIPBinds x :: XHsIPBinds GhcRn GhcRn
x (IPBinds _ ip_binds :: [LIPBind GhcRn]
ip_binds)) thing_inside :: TcM thing
thing_inside
  = do  { Class
ipClass <- Name -> TcM Class
tcLookupClass Name
ipClassName
        ; (given_ips :: [TyVar]
given_ips, ip_binds' :: [LIPBind GhcTc]
ip_binds') <-
            (LIPBind GhcRn
 -> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, LIPBind GhcTc))
-> [LIPBind GhcRn]
-> IOEnv (Env TcGblEnv TcLclEnv) ([TyVar], [LIPBind GhcTc])
forall (m :: * -> *) a b c.
Applicative m =>
(a -> m (b, c)) -> [a] -> m ([b], [c])
mapAndUnzipM ((SrcSpanLess (LIPBind GhcRn)
 -> TcM (TyVar, SrcSpanLess (LIPBind GhcTc)))
-> LIPBind GhcRn
-> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, LIPBind GhcTc)
forall a c b.
(HasSrcSpan a, HasSrcSpan c) =>
(SrcSpanLess a -> TcM (b, SrcSpanLess c)) -> a -> TcM (b, c)
wrapLocSndM (Class
-> IPBind GhcRn
-> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, IPBind GhcTc)
tc_ip_bind Class
ipClass)) [LIPBind GhcRn]
ip_binds

        -- If the binding binds ?x = E, we  must now
        -- discharge any ?x constraints in expr_lie
        -- See Note [Implicit parameter untouchables]
        ; (ev_binds :: TcEvBinds
ev_binds, result :: thing
result) <- SkolemInfo
-> [TyVar] -> [TyVar] -> TcM thing -> TcM (TcEvBinds, thing)
forall result.
SkolemInfo
-> [TyVar] -> [TyVar] -> TcM result -> TcM (TcEvBinds, result)
checkConstraints ([HsIPName] -> SkolemInfo
IPSkol [HsIPName]
ips)
                                  [] [TyVar]
given_ips TcM thing
thing_inside

        ; (HsLocalBinds GhcTc, thing) -> TcM (HsLocalBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (XHsIPBinds GhcTc GhcTc -> HsIPBinds GhcTc -> HsLocalBinds GhcTc
forall idL idR.
XHsIPBinds idL idR -> HsIPBinds idR -> HsLocalBindsLR idL idR
HsIPBinds XHsIPBinds GhcRn GhcRn
XHsIPBinds GhcTc GhcTc
x (XIPBinds GhcTc -> [LIPBind GhcTc] -> HsIPBinds GhcTc
forall id. XIPBinds id -> [LIPBind id] -> HsIPBinds id
IPBinds XIPBinds GhcTc
TcEvBinds
ev_binds [LIPBind GhcTc]
ip_binds') , thing
result) }
  where
    ips :: [HsIPName]
ips = [SrcSpanLess (Located HsIPName)
HsIPName
ip | (LIPBind GhcRn -> Located (SrcSpanLess (LIPBind GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ (IPBind _ (Left (dL->L _ ip)) _)) <- [LIPBind GhcRn]
ip_binds]

        -- I wonder if we should do these one at at time
        -- Consider     ?x = 4
        --              ?y = ?x + 1
    tc_ip_bind :: Class
-> IPBind GhcRn
-> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, IPBind GhcTc)
tc_ip_bind ipClass :: Class
ipClass (IPBind _ (Left (Located HsIPName -> Located (SrcSpanLess (Located HsIPName))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ ip :: SrcSpanLess (Located HsIPName)
ip)) expr :: LHsExpr GhcRn
expr)
       = do { Type
ty <- TcM Type
newOpenFlexiTyVarTy
            ; let p :: Type
p = FastString -> Type
mkStrLitTy (FastString -> Type) -> FastString -> Type
forall a b. (a -> b) -> a -> b
$ HsIPName -> FastString
hsIPNameFS SrcSpanLess (Located HsIPName)
HsIPName
ip
            ; TyVar
ip_id <- Class -> ThetaType -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newDict Class
ipClass [ Type
p, Type
ty ]
            ; LHsExpr GhcTc
expr' <- LHsExpr GhcRn -> ExpRhoType -> TcM (LHsExpr GhcTc)
tcMonoExpr LHsExpr GhcRn
expr (Type -> ExpRhoType
mkCheckExpType Type
ty)
            ; let d :: LHsExpr GhcTc
d = Class -> Type -> Type -> HsExpr GhcTc -> HsExpr GhcTc
forall (id :: Pass).
Class -> Type -> Type -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
toDict Class
ipClass Type
p Type
ty (HsExpr GhcTc -> HsExpr GhcTc) -> LHsExpr GhcTc -> LHsExpr GhcTc
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` LHsExpr GhcTc
expr'
            ; (TyVar, IPBind GhcTc)
-> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, IPBind GhcTc)
forall (m :: * -> *) a. Monad m => a -> m a
return (TyVar
ip_id, (XCIPBind GhcTc
-> Either (Located HsIPName) (IdP GhcTc)
-> LHsExpr GhcTc
-> IPBind GhcTc
forall id.
XCIPBind id
-> Either (Located HsIPName) (IdP id) -> LHsExpr id -> IPBind id
IPBind XCIPBind GhcTc
NoExt
noExt (TyVar -> Either (Located HsIPName) TyVar
forall a b. b -> Either a b
Right TyVar
ip_id) LHsExpr GhcTc
d)) }
    tc_ip_bind _ (IPBind _ (Right {}) _) = String -> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, IPBind GhcTc)
forall a. String -> a
panic "tc_ip_bind"
    tc_ip_bind _ (XIPBind _) = String -> IOEnv (Env TcGblEnv TcLclEnv) (TyVar, IPBind GhcTc)
forall a. String -> a
panic "tc_ip_bind"

    -- Coerces a `t` into a dictionry for `IP "x" t`.
    -- co : t -> IP "x" t
    toDict :: Class -> Type -> Type -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
toDict ipClass :: Class
ipClass x :: Type
x ty :: Type
ty = HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
forall (id :: Pass).
HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
mkHsWrap (HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id))
-> HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
forall a b. (a -> b) -> a -> b
$ TcCoercionR -> HsWrapper
mkWpCastR (TcCoercionR -> HsWrapper) -> TcCoercionR -> HsWrapper
forall a b. (a -> b) -> a -> b
$
                          Type -> TcCoercionR
wrapIP (Type -> TcCoercionR) -> Type -> TcCoercionR
forall a b. (a -> b) -> a -> b
$ Class -> ThetaType -> Type
mkClassPred Class
ipClass [Type
x,Type
ty]

tcLocalBinds (HsIPBinds _ (XHsIPBinds _ )) _ = String -> TcM (HsLocalBinds GhcTc, thing)
forall a. String -> a
panic "tcLocalBinds"
tcLocalBinds (XHsLocalBindsLR _)           _ = String -> TcM (HsLocalBinds GhcTc, thing)
forall a. String -> a
panic "tcLocalBinds"

{- Note [Implicit parameter untouchables]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We add the type variables in the types of the implicit parameters
as untouchables, not so much because we really must not unify them,
but rather because we otherwise end up with constraints like this
    Num alpha, Implic { wanted = alpha ~ Int }
The constraint solver solves alpha~Int by unification, but then
doesn't float that solved constraint out (it's not an unsolved
wanted).  Result disaster: the (Num alpha) is again solved, this
time by defaulting.  No no no.

However [Oct 10] this is all handled automatically by the
untouchable-range idea.
-}

tcValBinds :: TopLevelFlag
           -> [(RecFlag, LHsBinds GhcRn)] -> [LSig GhcRn]
           -> TcM thing
           -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing)

tcValBinds :: TopLevelFlag
-> [(RecFlag, LHsBinds GhcRn)]
-> [LSig GhcRn]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcValBinds top_lvl :: TopLevelFlag
top_lvl binds :: [(RecFlag, LHsBinds GhcRn)]
binds sigs :: [LSig GhcRn]
sigs thing_inside :: TcM thing
thing_inside
  = do  { let patsyns :: [PatSynBind GhcRn GhcRn]
patsyns = [(RecFlag, LHsBinds GhcRn)] -> [PatSynBind GhcRn GhcRn]
forall id. [(RecFlag, LHsBinds id)] -> [PatSynBind id id]
getPatSynBinds [(RecFlag, LHsBinds GhcRn)]
binds

            -- Typecheck the signature
        ; (poly_ids :: [TyVar]
poly_ids, sig_fn :: TcSigFun
sig_fn) <- [PatSynBind GhcRn GhcRn]
-> TcM ([TyVar], TcSigFun) -> TcM ([TyVar], TcSigFun)
forall a. [PatSynBind GhcRn GhcRn] -> TcM a -> TcM a
tcAddPatSynPlaceholders [PatSynBind GhcRn GhcRn]
patsyns (TcM ([TyVar], TcSigFun) -> TcM ([TyVar], TcSigFun))
-> TcM ([TyVar], TcSigFun) -> TcM ([TyVar], TcSigFun)
forall a b. (a -> b) -> a -> b
$
                                [LSig GhcRn] -> TcM ([TyVar], TcSigFun)
tcTySigs [LSig GhcRn]
sigs

        ; let prag_fn :: TcPragEnv
prag_fn = [LSig GhcRn] -> LHsBinds GhcRn -> TcPragEnv
mkPragEnv [LSig GhcRn]
sigs (((RecFlag, LHsBinds GhcRn) -> LHsBinds GhcRn -> LHsBinds GhcRn)
-> LHsBinds GhcRn -> [(RecFlag, LHsBinds GhcRn)] -> LHsBinds GhcRn
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (LHsBinds GhcRn -> LHsBinds GhcRn -> LHsBinds GhcRn
forall a. Bag a -> Bag a -> Bag a
unionBags (LHsBinds GhcRn -> LHsBinds GhcRn -> LHsBinds GhcRn)
-> ((RecFlag, LHsBinds GhcRn) -> LHsBinds GhcRn)
-> (RecFlag, LHsBinds GhcRn)
-> LHsBinds GhcRn
-> LHsBinds GhcRn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RecFlag, LHsBinds GhcRn) -> LHsBinds GhcRn
forall a b. (a, b) -> b
snd) LHsBinds GhcRn
forall a. Bag a
emptyBag [(RecFlag, LHsBinds GhcRn)]
binds)

                -- Extend the envt right away with all the Ids
                -- declared with complete type signatures
                -- Do not extend the TcBinderStack; instead
                -- we extend it on a per-rhs basis in tcExtendForRhs
        ; TopLevelFlag
-> [TyVar]
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall a. TopLevelFlag -> [TyVar] -> TcM a -> TcM a
tcExtendSigIds TopLevelFlag
top_lvl [TyVar]
poly_ids (TcM ([(RecFlag, LHsBinds GhcTc)], thing)
 -> TcM ([(RecFlag, LHsBinds GhcTc)], thing))
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall a b. (a -> b) -> a -> b
$ do
            { (binds' :: [(RecFlag, LHsBinds GhcTc)]
binds', (extra_binds' :: [(RecFlag, LHsBinds GhcTc)]
extra_binds', thing :: thing
thing)) <- TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> [(RecFlag, LHsBinds GhcRn)]
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM
     ([(RecFlag, LHsBinds GhcTc)], ([(RecFlag, LHsBinds GhcTc)], thing))
forall thing.
TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> [(RecFlag, LHsBinds GhcRn)]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcBindGroups TopLevelFlag
top_lvl TcSigFun
sig_fn TcPragEnv
prag_fn [(RecFlag, LHsBinds GhcRn)]
binds (TcM ([(RecFlag, LHsBinds GhcTc)], thing)
 -> TcM
      ([(RecFlag, LHsBinds GhcTc)],
       ([(RecFlag, LHsBinds GhcTc)], thing)))
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM
     ([(RecFlag, LHsBinds GhcTc)], ([(RecFlag, LHsBinds GhcTc)], thing))
forall a b. (a -> b) -> a -> b
$ do
                   { thing
thing <- TcM thing
thing_inside
                     -- See Note [Pattern synonym builders don't yield dependencies]
                     --     in RnBinds
                   ; [LHsBinds GhcTc]
patsyn_builders <- (PatSynBind GhcRn GhcRn
 -> IOEnv (Env TcGblEnv TcLclEnv) (LHsBinds GhcTc))
-> [PatSynBind GhcRn GhcRn]
-> IOEnv (Env TcGblEnv TcLclEnv) [LHsBinds GhcTc]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM PatSynBind GhcRn GhcRn
-> IOEnv (Env TcGblEnv TcLclEnv) (LHsBinds GhcTc)
tcPatSynBuilderBind [PatSynBind GhcRn GhcRn]
patsyns
                   ; let extra_binds :: [(RecFlag, LHsBinds GhcTc)]
extra_binds = [ (RecFlag
NonRecursive, LHsBinds GhcTc
builder) | LHsBinds GhcTc
builder <- [LHsBinds GhcTc]
patsyn_builders ]
                   ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ([(RecFlag, LHsBinds GhcTc)]
extra_binds, thing
thing) }
            ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ([(RecFlag, LHsBinds GhcTc)]
binds' [(RecFlag, LHsBinds GhcTc)]
-> [(RecFlag, LHsBinds GhcTc)] -> [(RecFlag, LHsBinds GhcTc)]
forall a. [a] -> [a] -> [a]
++ [(RecFlag, LHsBinds GhcTc)]
extra_binds', thing
thing) }}

------------------------
tcBindGroups :: TopLevelFlag -> TcSigFun -> TcPragEnv
             -> [(RecFlag, LHsBinds GhcRn)] -> TcM thing
             -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing)
-- Typecheck a whole lot of value bindings,
-- one strongly-connected component at a time
-- Here a "strongly connected component" has the strightforward
-- meaning of a group of bindings that mention each other,
-- ignoring type signatures (that part comes later)

tcBindGroups :: TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> [(RecFlag, LHsBinds GhcRn)]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcBindGroups _ _ _ [] thing_inside :: TcM thing
thing_inside
  = do  { thing
thing <- TcM thing
thing_inside
        ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ([], thing
thing) }

tcBindGroups top_lvl :: TopLevelFlag
top_lvl sig_fn :: TcSigFun
sig_fn prag_fn :: TcPragEnv
prag_fn (group :: (RecFlag, LHsBinds GhcRn)
group : groups :: [(RecFlag, LHsBinds GhcRn)]
groups) thing_inside :: TcM thing
thing_inside
  = do  { -- See Note [Closed binder groups]
          TcTypeEnv
type_env <- TcM TcTypeEnv
getLclTypeEnv
        ; let closed :: IsGroupClosed
closed = TcTypeEnv -> LHsBinds GhcRn -> IsGroupClosed
isClosedBndrGroup TcTypeEnv
type_env ((RecFlag, LHsBinds GhcRn) -> LHsBinds GhcRn
forall a b. (a, b) -> b
snd (RecFlag, LHsBinds GhcRn)
group)
        ; (group' :: [(RecFlag, LHsBinds GhcTc)]
group', (groups' :: [(RecFlag, LHsBinds GhcTc)]
groups', thing :: thing
thing))
                <- TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> (RecFlag, LHsBinds GhcRn)
-> IsGroupClosed
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM
     ([(RecFlag, LHsBinds GhcTc)], ([(RecFlag, LHsBinds GhcTc)], thing))
forall thing.
TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> (RecFlag, LHsBinds GhcRn)
-> IsGroupClosed
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tc_group TopLevelFlag
top_lvl TcSigFun
sig_fn TcPragEnv
prag_fn (RecFlag, LHsBinds GhcRn)
group IsGroupClosed
closed (TcM ([(RecFlag, LHsBinds GhcTc)], thing)
 -> TcM
      ([(RecFlag, LHsBinds GhcTc)],
       ([(RecFlag, LHsBinds GhcTc)], thing)))
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM
     ([(RecFlag, LHsBinds GhcTc)], ([(RecFlag, LHsBinds GhcTc)], thing))
forall a b. (a -> b) -> a -> b
$
                   TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> [(RecFlag, LHsBinds GhcRn)]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall thing.
TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> [(RecFlag, LHsBinds GhcRn)]
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tcBindGroups TopLevelFlag
top_lvl TcSigFun
sig_fn TcPragEnv
prag_fn [(RecFlag, LHsBinds GhcRn)]
groups TcM thing
thing_inside
        ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ([(RecFlag, LHsBinds GhcTc)]
group' [(RecFlag, LHsBinds GhcTc)]
-> [(RecFlag, LHsBinds GhcTc)] -> [(RecFlag, LHsBinds GhcTc)]
forall a. [a] -> [a] -> [a]
++ [(RecFlag, LHsBinds GhcTc)]
groups', thing
thing) }

-- Note [Closed binder groups]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
--  A mutually recursive group is "closed" if all of the free variables of
--  the bindings are closed. For example
--
-- >  h = \x -> let f = ...g...
-- >                g = ....f...x...
-- >             in ...
--
-- Here @g@ is not closed because it mentions @x@; and hence neither is @f@
-- closed.
--
-- So we need to compute closed-ness on each strongly connected components,
-- before we sub-divide it based on what type signatures it has.
--

------------------------
tc_group :: forall thing.
            TopLevelFlag -> TcSigFun -> TcPragEnv
         -> (RecFlag, LHsBinds GhcRn) -> IsGroupClosed -> TcM thing
         -> TcM ([(RecFlag, LHsBinds GhcTcId)], thing)

-- Typecheck one strongly-connected component of the original program.
-- We get a list of groups back, because there may
-- be specialisations etc as well

tc_group :: TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> (RecFlag, LHsBinds GhcRn)
-> IsGroupClosed
-> TcM thing
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
tc_group top_lvl :: TopLevelFlag
top_lvl sig_fn :: TcSigFun
sig_fn prag_fn :: TcPragEnv
prag_fn (NonRecursive, binds :: LHsBinds GhcRn
binds) closed :: IsGroupClosed
closed thing_inside :: TcM thing
thing_inside
        -- A single non-recursive binding
        -- We want to keep non-recursive things non-recursive
        -- so that we desugar unlifted bindings correctly
  = do { let bind :: LHsBindLR GhcRn GhcRn
bind = case LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
binds of
                 [bind :: LHsBindLR GhcRn GhcRn
bind] -> LHsBindLR GhcRn GhcRn
bind
                 []     -> String -> LHsBindLR GhcRn GhcRn
forall a. String -> a
panic "tc_group: empty list of binds"
                 _      -> String -> LHsBindLR GhcRn GhcRn
forall a. String -> a
panic "tc_group: NonRecursive binds is not a singleton bag"
       ; (bind' :: LHsBinds GhcTc
bind', thing :: thing
thing) <- TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> LHsBindLR GhcRn GhcRn
-> IsGroupClosed
-> TcM thing
-> TcM (LHsBinds GhcTc, thing)
forall thing.
TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> LHsBindLR GhcRn GhcRn
-> IsGroupClosed
-> TcM thing
-> TcM (LHsBinds GhcTc, thing)
tc_single TopLevelFlag
top_lvl TcSigFun
sig_fn TcPragEnv
prag_fn LHsBindLR GhcRn GhcRn
bind IsGroupClosed
closed
                                     TcM thing
thing_inside
       ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ( [(RecFlag
NonRecursive, LHsBinds GhcTc
bind')], thing
thing) }

tc_group top_lvl :: TopLevelFlag
top_lvl sig_fn :: TcSigFun
sig_fn prag_fn :: TcPragEnv
prag_fn (Recursive, binds :: LHsBinds GhcRn
binds) closed :: IsGroupClosed
closed thing_inside :: TcM thing
thing_inside
  =     -- To maximise polymorphism, we do a new
        -- strongly-connected-component analysis, this time omitting
        -- any references to variables with type signatures.
        -- (This used to be optional, but isn't now.)
        -- See Note [Polymorphic recursion] in HsBinds.
    do  { String -> SDoc -> TcRn ()
traceTc "tc_group rec" (LHsBinds GhcRn -> SDoc
forall (idL :: Pass) (idR :: Pass).
(OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) =>
LHsBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
pprLHsBinds LHsBinds GhcRn
binds)
        ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
hasPatSyn (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$ LHsBinds GhcRn -> TcRn ()
forall (p :: Pass) a.
OutputableBndrId (GhcPass p) =>
LHsBinds (GhcPass p) -> TcM a
recursivePatSynErr LHsBinds GhcRn
binds
        ; (binds1 :: LHsBinds GhcTc
binds1, thing :: thing
thing) <- [SCC (LHsBindLR GhcRn GhcRn)] -> TcM (LHsBinds GhcTc, thing)
go [SCC (LHsBindLR GhcRn GhcRn)]
sccs
        ; ([(RecFlag, LHsBinds GhcTc)], thing)
-> TcM ([(RecFlag, LHsBinds GhcTc)], thing)
forall (m :: * -> *) a. Monad m => a -> m a
return ([(RecFlag
Recursive, LHsBinds GhcTc
binds1)], thing
thing) }
                -- Rec them all together
  where
    hasPatSyn :: Bool
hasPatSyn = (LHsBindLR GhcRn GhcRn -> Bool) -> LHsBinds GhcRn -> Bool
forall a. (a -> Bool) -> Bag a -> Bool
anyBag (HsBindLR GhcRn GhcRn -> Bool
forall idL idR. HsBindLR idL idR -> Bool
isPatSyn (HsBindLR GhcRn GhcRn -> Bool)
-> (LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn)
-> LHsBindLR GhcRn GhcRn
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) LHsBinds GhcRn
binds
    isPatSyn :: HsBindLR idL idR -> Bool
isPatSyn PatSynBind{} = Bool
True
    isPatSyn _ = Bool
False

    sccs :: [SCC (LHsBind GhcRn)]
    sccs :: [SCC (LHsBindLR GhcRn GhcRn)]
sccs = [Node BKey (LHsBindLR GhcRn GhcRn)]
-> [SCC (LHsBindLR GhcRn GhcRn)]
forall key payload.
Uniquable key =>
[Node key payload] -> [SCC payload]
stronglyConnCompFromEdgedVerticesUniq (TcSigFun -> LHsBinds GhcRn -> [Node BKey (LHsBindLR GhcRn GhcRn)]
mkEdges TcSigFun
sig_fn LHsBinds GhcRn
binds)

    go :: [SCC (LHsBind GhcRn)] -> TcM (LHsBinds GhcTcId, thing)
    go :: [SCC (LHsBindLR GhcRn GhcRn)] -> TcM (LHsBinds GhcTc, thing)
go (scc :: SCC (LHsBindLR GhcRn GhcRn)
scc:sccs :: [SCC (LHsBindLR GhcRn GhcRn)]
sccs) = do  { (binds1 :: LHsBinds GhcTc
binds1, ids1 :: [TyVar]
ids1) <- SCC (LHsBindLR GhcRn GhcRn) -> TcM (LHsBinds GhcTc, [TyVar])
tc_scc SCC (LHsBindLR GhcRn GhcRn)
scc
                        ; (binds2 :: LHsBinds GhcTc
binds2, thing :: thing
thing) <- TopLevelFlag
-> TcSigFun
-> IsGroupClosed
-> [TyVar]
-> TcM (LHsBinds GhcTc, thing)
-> TcM (LHsBinds GhcTc, thing)
forall a.
TopLevelFlag
-> TcSigFun -> IsGroupClosed -> [TyVar] -> TcM a -> TcM a
tcExtendLetEnv TopLevelFlag
top_lvl TcSigFun
sig_fn
                                                            IsGroupClosed
closed [TyVar]
ids1 (TcM (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing))
-> TcM (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing)
forall a b. (a -> b) -> a -> b
$
                                             [SCC (LHsBindLR GhcRn GhcRn)] -> TcM (LHsBinds GhcTc, thing)
go [SCC (LHsBindLR GhcRn GhcRn)]
sccs
                        ; (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
binds1 LHsBinds GhcTc -> LHsBinds GhcTc -> LHsBinds GhcTc
forall a. Bag a -> Bag a -> Bag a
`unionBags` LHsBinds GhcTc
binds2, thing
thing) }
    go []         = do  { thing
thing <- TcM thing
thing_inside; (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
forall a. Bag a
emptyBag, thing
thing) }

    tc_scc :: SCC (LHsBindLR GhcRn GhcRn) -> TcM (LHsBinds GhcTc, [TyVar])
tc_scc (AcyclicSCC bind :: LHsBindLR GhcRn GhcRn
bind) = RecFlag -> [LHsBindLR GhcRn GhcRn] -> TcM (LHsBinds GhcTc, [TyVar])
tc_sub_group RecFlag
NonRecursive [LHsBindLR GhcRn GhcRn
bind]
    tc_scc (CyclicSCC binds :: [LHsBindLR GhcRn GhcRn]
binds) = RecFlag -> [LHsBindLR GhcRn GhcRn] -> TcM (LHsBinds GhcTc, [TyVar])
tc_sub_group RecFlag
Recursive    [LHsBindLR GhcRn GhcRn]
binds

    tc_sub_group :: RecFlag -> [LHsBindLR GhcRn GhcRn] -> TcM (LHsBinds GhcTc, [TyVar])
tc_sub_group rec_tc :: RecFlag
rec_tc binds :: [LHsBindLR GhcRn GhcRn]
binds =
      TcSigFun
-> TcPragEnv
-> RecFlag
-> RecFlag
-> IsGroupClosed
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyBinds TcSigFun
sig_fn TcPragEnv
prag_fn RecFlag
Recursive RecFlag
rec_tc IsGroupClosed
closed [LHsBindLR GhcRn GhcRn]
binds

recursivePatSynErr :: OutputableBndrId (GhcPass p) =>
                      LHsBinds (GhcPass p) -> TcM a
recursivePatSynErr :: LHsBinds (GhcPass p) -> TcM a
recursivePatSynErr binds :: LHsBinds (GhcPass p)
binds
  = SDoc -> TcM a
forall a. SDoc -> TcM a
failWithTc (SDoc -> TcM a) -> SDoc -> TcM a
forall a b. (a -> b) -> a -> b
$
    SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "Recursive pattern synonym definition with following bindings:")
       2 ([SDoc] -> SDoc
vcat ([SDoc] -> SDoc) -> [SDoc] -> SDoc
forall a b. (a -> b) -> a -> b
$ (LHsBindLR (GhcPass p) (GhcPass p) -> SDoc)
-> [LHsBindLR (GhcPass p) (GhcPass p)] -> [SDoc]
forall a b. (a -> b) -> [a] -> [b]
map LHsBindLR (GhcPass p) (GhcPass p) -> SDoc
forall p a idR.
(Outputable (IdP p), HasSrcSpan a, HasSrcSpan (LPat p),
 SrcSpanLess a ~ HsBindLR p idR, SrcSpanLess (LPat p) ~ LPat p) =>
a -> SDoc
pprLBind ([LHsBindLR (GhcPass p) (GhcPass p)] -> [SDoc])
-> (LHsBinds (GhcPass p) -> [LHsBindLR (GhcPass p) (GhcPass p)])
-> LHsBinds (GhcPass p)
-> [SDoc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LHsBinds (GhcPass p) -> [LHsBindLR (GhcPass p) (GhcPass p)]
forall a. Bag a -> [a]
bagToList (LHsBinds (GhcPass p) -> [SDoc]) -> LHsBinds (GhcPass p) -> [SDoc]
forall a b. (a -> b) -> a -> b
$ LHsBinds (GhcPass p)
binds)
  where
    pprLoc :: a -> SDoc
pprLoc loc :: a
loc  = SDoc -> SDoc
parens (String -> SDoc
text "defined at" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
loc)
    pprLBind :: a -> SDoc
pprLBind (a -> Located (SrcSpanLess a)
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L loc :: SrcSpan
loc bind :: SrcSpanLess a
bind) = (IdP p -> SDoc) -> [IdP p] -> SDoc
forall a. (a -> SDoc) -> [a] -> SDoc
pprWithCommas IdP p -> SDoc
forall a. Outputable a => a -> SDoc
ppr (HsBindLR p idR -> [IdP p]
forall p idR.
(SrcSpanLess (LPat p) ~ LPat p, HasSrcSpan (LPat p)) =>
HsBindLR p idR -> [IdP p]
collectHsBindBinders SrcSpanLess a
HsBindLR p idR
bind)
                                SDoc -> SDoc -> SDoc
<+> SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
pprLoc SrcSpan
loc

tc_single :: forall thing.
            TopLevelFlag -> TcSigFun -> TcPragEnv
          -> LHsBind GhcRn -> IsGroupClosed -> TcM thing
          -> TcM (LHsBinds GhcTcId, thing)
tc_single :: TopLevelFlag
-> TcSigFun
-> TcPragEnv
-> LHsBindLR GhcRn GhcRn
-> IsGroupClosed
-> TcM thing
-> TcM (LHsBinds GhcTc, thing)
tc_single _top_lvl :: TopLevelFlag
_top_lvl sig_fn :: TcSigFun
sig_fn _prag_fn :: TcPragEnv
_prag_fn
          (LHsBindLR GhcRn GhcRn
-> Located (SrcSpanLess (LHsBindLR GhcRn GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ (PatSynBind _ psb@PSB{ psb_id = (dL->L _ name) }))
          _ thing_inside :: TcM thing
thing_inside
  = do { (aux_binds :: LHsBinds GhcTc
aux_binds, tcg_env :: TcGblEnv
tcg_env) <- PatSynBind GhcRn GhcRn
-> Maybe TcSigInfo -> TcM (LHsBinds GhcTc, TcGblEnv)
tcPatSynDecl PatSynBind GhcRn GhcRn
psb (TcSigFun
sig_fn Name
SrcSpanLess (Located Name)
name)
       ; thing
thing <- TcGblEnv -> TcM thing -> TcM thing
forall gbl lcl a. gbl -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
setGblEnv TcGblEnv
tcg_env TcM thing
thing_inside
       ; (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
aux_binds, thing
thing)
       }

tc_single top_lvl :: TopLevelFlag
top_lvl sig_fn :: TcSigFun
sig_fn prag_fn :: TcPragEnv
prag_fn lbind :: LHsBindLR GhcRn GhcRn
lbind closed :: IsGroupClosed
closed thing_inside :: TcM thing
thing_inside
  = do { (binds1 :: LHsBinds GhcTc
binds1, ids :: [TyVar]
ids) <- TcSigFun
-> TcPragEnv
-> RecFlag
-> RecFlag
-> IsGroupClosed
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyBinds TcSigFun
sig_fn TcPragEnv
prag_fn
                                      RecFlag
NonRecursive RecFlag
NonRecursive
                                      IsGroupClosed
closed
                                      [LHsBindLR GhcRn GhcRn
lbind]
       ; thing
thing <- TopLevelFlag
-> TcSigFun -> IsGroupClosed -> [TyVar] -> TcM thing -> TcM thing
forall a.
TopLevelFlag
-> TcSigFun -> IsGroupClosed -> [TyVar] -> TcM a -> TcM a
tcExtendLetEnv TopLevelFlag
top_lvl TcSigFun
sig_fn IsGroupClosed
closed [TyVar]
ids TcM thing
thing_inside
       ; (LHsBinds GhcTc, thing) -> TcM (LHsBinds GhcTc, thing)
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
binds1, thing
thing) }

------------------------
type BKey = Int -- Just number off the bindings

mkEdges :: TcSigFun -> LHsBinds GhcRn -> [Node BKey (LHsBind GhcRn)]
-- See Note [Polymorphic recursion] in HsBinds.
mkEdges :: TcSigFun -> LHsBinds GhcRn -> [Node BKey (LHsBindLR GhcRn GhcRn)]
mkEdges sig_fn :: TcSigFun
sig_fn binds :: LHsBinds GhcRn
binds
  = [ LHsBindLR GhcRn GhcRn
-> BKey -> [BKey] -> Node BKey (LHsBindLR GhcRn GhcRn)
forall key payload. payload -> key -> [key] -> Node key payload
DigraphNode LHsBindLR GhcRn GhcRn
bind BKey
key [BKey
key | Name
n <- UniqSet Name -> [Name]
forall elt. UniqSet elt -> [elt]
nonDetEltsUniqSet (HsBindLR GhcRn GhcRn -> UniqSet Name
forall idL idR.
(XFunBind idL idR ~ UniqSet Name,
 XPatBind idL idR ~ UniqSet Name) =>
HsBindLR idL idR -> UniqSet Name
bind_fvs (LHsBindLR GhcRn GhcRn -> SrcSpanLess (LHsBindLR GhcRn GhcRn)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc LHsBindLR GhcRn GhcRn
bind)),
                         Just key :: BKey
key <- [NameEnv BKey -> Name -> Maybe BKey
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv NameEnv BKey
key_map Name
n], Name -> Bool
no_sig Name
n ]
    | (bind :: LHsBindLR GhcRn GhcRn
bind, key :: BKey
key) <- [(LHsBindLR GhcRn GhcRn, BKey)]
keyd_binds
    ]
    -- It's OK to use nonDetEltsUFM here as stronglyConnCompFromEdgedVertices
    -- is still deterministic even if the edges are in nondeterministic order
    -- as explained in Note [Deterministic SCC] in Digraph.
  where
    bind_fvs :: HsBindLR idL idR -> UniqSet Name
bind_fvs (FunBind { fun_ext :: forall idL idR. HsBindLR idL idR -> XFunBind idL idR
fun_ext = XFunBind idL idR
fvs }) = UniqSet Name
XFunBind idL idR
fvs
    bind_fvs (PatBind { pat_ext :: forall idL idR. HsBindLR idL idR -> XPatBind idL idR
pat_ext = XPatBind idL idR
fvs }) = UniqSet Name
XPatBind idL idR
fvs
    bind_fvs _                           = UniqSet Name
emptyNameSet

    no_sig :: Name -> Bool
    no_sig :: Name -> Bool
no_sig n :: Name
n = Bool -> Bool
not (TcSigFun -> Name -> Bool
hasCompleteSig TcSigFun
sig_fn Name
n)

    keyd_binds :: [(LHsBindLR GhcRn GhcRn, BKey)]
keyd_binds = LHsBinds GhcRn -> [LHsBindLR GhcRn GhcRn]
forall a. Bag a -> [a]
bagToList LHsBinds GhcRn
binds [LHsBindLR GhcRn GhcRn]
-> [BKey] -> [(LHsBindLR GhcRn GhcRn, BKey)]
forall a b. [a] -> [b] -> [(a, b)]
`zip` [0::BKey ..]

    key_map :: NameEnv BKey     -- Which binding it comes from
    key_map :: NameEnv BKey
key_map = [(Name, BKey)] -> NameEnv BKey
forall a. [(Name, a)] -> NameEnv a
mkNameEnv [(Name
bndr, BKey
key) | (LHsBindLR GhcRn GhcRn
-> Located (SrcSpanLess (LHsBindLR GhcRn GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ bind :: SrcSpanLess (LHsBindLR GhcRn GhcRn)
bind, key :: BKey
key) <- [(LHsBindLR GhcRn GhcRn, BKey)]
keyd_binds
                                     , Name
bndr <- HsBindLR GhcRn GhcRn -> [IdP GhcRn]
forall p idR.
(SrcSpanLess (LPat p) ~ LPat p, HasSrcSpan (LPat p)) =>
HsBindLR p idR -> [IdP p]
collectHsBindBinders SrcSpanLess (LHsBindLR GhcRn GhcRn)
HsBindLR GhcRn GhcRn
bind ]

------------------------
tcPolyBinds :: TcSigFun -> TcPragEnv
            -> RecFlag         -- Whether the group is really recursive
            -> RecFlag         -- Whether it's recursive after breaking
                               -- dependencies based on type signatures
            -> IsGroupClosed   -- Whether the group is closed
            -> [LHsBind GhcRn]  -- None are PatSynBind
            -> TcM (LHsBinds GhcTcId, [TcId])

-- Typechecks a single bunch of values bindings all together,
-- and generalises them.  The bunch may be only part of a recursive
-- group, because we use type signatures to maximise polymorphism
--
-- Returns a list because the input may be a single non-recursive binding,
-- in which case the dependency order of the resulting bindings is
-- important.
--
-- Knows nothing about the scope of the bindings
-- None of the bindings are pattern synonyms

tcPolyBinds :: TcSigFun
-> TcPragEnv
-> RecFlag
-> RecFlag
-> IsGroupClosed
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyBinds sig_fn :: TcSigFun
sig_fn prag_fn :: TcPragEnv
prag_fn rec_group :: RecFlag
rec_group rec_tc :: RecFlag
rec_tc closed :: IsGroupClosed
closed bind_list :: [LHsBindLR GhcRn GhcRn]
bind_list
  = SrcSpan
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc                              (TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar]))
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall a b. (a -> b) -> a -> b
$
    TcM (LHsBinds GhcTc, [TyVar])
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall r. TcRn r -> TcRn r -> TcRn r
recoverM ([Name] -> TcSigFun -> TcM (LHsBinds GhcTc, [TyVar])
recoveryCode [Name]
[IdP GhcRn]
binder_names TcSigFun
sig_fn) (TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar]))
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall a b. (a -> b) -> a -> b
$ do
        -- Set up main recover; take advantage of any type sigs

    { String -> SDoc -> TcRn ()
traceTc "------------------------------------------------" SDoc
Outputable.empty
    ; String -> SDoc -> TcRn ()
traceTc "Bindings for {" ([Name] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Name]
[IdP GhcRn]
binder_names)
    ; DynFlags
dflags   <- IOEnv (Env TcGblEnv TcLclEnv) DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
    ; let plan :: GeneralisationPlan
plan = DynFlags
-> [LHsBindLR GhcRn GhcRn]
-> IsGroupClosed
-> TcSigFun
-> GeneralisationPlan
decideGeneralisationPlan DynFlags
dflags [LHsBindLR GhcRn GhcRn]
bind_list IsGroupClosed
closed TcSigFun
sig_fn
    ; String -> SDoc -> TcRn ()
traceTc "Generalisation plan" (GeneralisationPlan -> SDoc
forall a. Outputable a => a -> SDoc
ppr GeneralisationPlan
plan)
    ; result :: (LHsBinds GhcTc, [TyVar])
result@(_, poly_ids :: [TyVar]
poly_ids) <- case GeneralisationPlan
plan of
         NoGen              -> RecFlag
-> TcPragEnv
-> TcSigFun
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyNoGen RecFlag
rec_tc TcPragEnv
prag_fn TcSigFun
sig_fn [LHsBindLR GhcRn GhcRn]
bind_list
         InferGen mn :: Bool
mn        -> RecFlag
-> TcPragEnv
-> TcSigFun
-> Bool
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyInfer RecFlag
rec_tc TcPragEnv
prag_fn TcSigFun
sig_fn Bool
mn [LHsBindLR GhcRn GhcRn]
bind_list
         CheckGen lbind :: LHsBindLR GhcRn GhcRn
lbind sig :: TcIdSigInfo
sig -> TcPragEnv
-> TcIdSigInfo
-> LHsBindLR GhcRn GhcRn
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyCheck TcPragEnv
prag_fn TcIdSigInfo
sig LHsBindLR GhcRn GhcRn
lbind

    ; String -> SDoc -> TcRn ()
traceTc "} End of bindings for" ([SDoc] -> SDoc
vcat [ [Name] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Name]
[IdP GhcRn]
binder_names, RecFlag -> SDoc
forall a. Outputable a => a -> SDoc
ppr RecFlag
rec_group
                                            , [SDoc] -> SDoc
vcat [TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
id SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
idType TyVar
id) | TyVar
id <- [TyVar]
poly_ids]
                                          ])

    ; (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc, [TyVar])
result }
  where
    binder_names :: [IdP GhcRn]
binder_names = [LHsBindLR GhcRn GhcRn] -> [IdP GhcRn]
forall (p :: Pass) idR.
[LHsBindLR (GhcPass p) idR] -> [IdP (GhcPass p)]
collectHsBindListBinders [LHsBindLR GhcRn GhcRn]
bind_list
    loc :: SrcSpan
loc = (SrcSpan -> SrcSpan -> SrcSpan) -> [SrcSpan] -> SrcSpan
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 SrcSpan -> SrcSpan -> SrcSpan
combineSrcSpans ((LHsBindLR GhcRn GhcRn -> SrcSpan)
-> [LHsBindLR GhcRn GhcRn] -> [SrcSpan]
forall a b. (a -> b) -> [a] -> [b]
map LHsBindLR GhcRn GhcRn -> SrcSpan
forall a. HasSrcSpan a => a -> SrcSpan
getLoc [LHsBindLR GhcRn GhcRn]
bind_list)
         -- The mbinds have been dependency analysed and
         -- may no longer be adjacent; so find the narrowest
         -- span that includes them all

--------------
-- If typechecking the binds fails, then return with each
-- signature-less binder given type (forall a.a), to minimise
-- subsequent error messages
recoveryCode :: [Name] -> TcSigFun -> TcM (LHsBinds GhcTcId, [Id])
recoveryCode :: [Name] -> TcSigFun -> TcM (LHsBinds GhcTc, [TyVar])
recoveryCode binder_names :: [Name]
binder_names sig_fn :: TcSigFun
sig_fn
  = do  { String -> SDoc -> TcRn ()
traceTc "tcBindsWithSigs: error recovery" ([Name] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [Name]
binder_names)
        ; let poly_ids :: [TyVar]
poly_ids = (Name -> TyVar) -> [Name] -> [TyVar]
forall a b. (a -> b) -> [a] -> [b]
map Name -> TyVar
mk_dummy [Name]
binder_names
        ; (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
forall a. Bag a
emptyBag, [TyVar]
poly_ids) }
  where
    mk_dummy :: Name -> TyVar
mk_dummy name :: Name
name
      | Just sig :: TcSigInfo
sig <- TcSigFun
sig_fn Name
name
      , Just poly_id :: TyVar
poly_id <- TcSigInfo -> Maybe TyVar
completeSigPolyId_maybe TcSigInfo
sig
      = TyVar
poly_id
      | Bool
otherwise
      = Name -> Type -> TyVar
mkLocalId Name
name Type
forall_a_a

forall_a_a :: TcType
-- At one point I had (forall r (a :: TYPE r). a), but of course
-- that type is ill-formed: its mentions 'r' which escapes r's scope.
-- Another alternative would be (forall (a :: TYPE kappa). a), where
-- kappa is a unification variable. But I don't think we need that
-- complication here. I'm going to just use (forall (a::*). a).
-- See Trac #15276
forall_a_a :: Type
forall_a_a = [TyVar] -> Type -> Type
mkSpecForAllTys [TyVar
alphaTyVar] Type
alphaTy

{- *********************************************************************
*                                                                      *
                         tcPolyNoGen
*                                                                      *
********************************************************************* -}

tcPolyNoGen     -- No generalisation whatsoever
  :: RecFlag       -- Whether it's recursive after breaking
                   -- dependencies based on type signatures
  -> TcPragEnv -> TcSigFun
  -> [LHsBind GhcRn]
  -> TcM (LHsBinds GhcTcId, [TcId])

tcPolyNoGen :: RecFlag
-> TcPragEnv
-> TcSigFun
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyNoGen rec_tc :: RecFlag
rec_tc prag_fn :: TcPragEnv
prag_fn tc_sig_fn :: TcSigFun
tc_sig_fn bind_list :: [LHsBindLR GhcRn GhcRn]
bind_list
  = do { (binds' :: LHsBinds GhcTc
binds', mono_infos :: [MonoBindInfo]
mono_infos) <- RecFlag
-> TcSigFun
-> LetBndrSpec
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
tcMonoBinds RecFlag
rec_tc TcSigFun
tc_sig_fn
                                             (TcPragEnv -> LetBndrSpec
LetGblBndr TcPragEnv
prag_fn)
                                             [LHsBindLR GhcRn GhcRn]
bind_list
       ; [TyVar]
mono_ids' <- (MonoBindInfo -> IOEnv (Env TcGblEnv TcLclEnv) TyVar)
-> [MonoBindInfo] -> TcM [TyVar]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM MonoBindInfo -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
tc_mono_info [MonoBindInfo]
mono_infos
       ; (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBinds GhcTc
binds', [TyVar]
mono_ids') }
  where
    tc_mono_info :: MonoBindInfo -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
tc_mono_info (MBI { mbi_poly_name :: MonoBindInfo -> Name
mbi_poly_name = Name
name, mbi_mono_id :: MonoBindInfo -> TyVar
mbi_mono_id = TyVar
mono_id })
      = do { [LTcSpecPrag]
_specs <- TyVar -> [LSig GhcRn] -> TcM [LTcSpecPrag]
tcSpecPrags TyVar
mono_id (TcPragEnv -> Name -> [LSig GhcRn]
lookupPragEnv TcPragEnv
prag_fn Name
name)
           ; TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall (m :: * -> *) a. Monad m => a -> m a
return TyVar
mono_id }
           -- NB: tcPrags generates error messages for
           --     specialisation pragmas for non-overloaded sigs
           -- Indeed that is why we call it here!
           -- So we can safely ignore _specs


{- *********************************************************************
*                                                                      *
                         tcPolyCheck
*                                                                      *
********************************************************************* -}

tcPolyCheck :: TcPragEnv
            -> TcIdSigInfo     -- Must be a complete signature
            -> LHsBind GhcRn   -- Must be a FunBind
            -> TcM (LHsBinds GhcTcId, [TcId])
-- There is just one binding,
--   it is a Funbind
--   it has a complete type signature,
tcPolyCheck :: TcPragEnv
-> TcIdSigInfo
-> LHsBindLR GhcRn GhcRn
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyCheck prag_fn :: TcPragEnv
prag_fn
            (CompleteSig { sig_bndr :: TcIdSigInfo -> TyVar
sig_bndr  = TyVar
poly_id
                         , sig_ctxt :: TcIdSigInfo -> UserTypeCtxt
sig_ctxt  = UserTypeCtxt
ctxt
                         , sig_loc :: TcIdSigInfo -> SrcSpan
sig_loc   = SrcSpan
sig_loc })
            (LHsBindLR GhcRn GhcRn
-> Located (SrcSpanLess (LHsBindLR GhcRn GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L loc :: SrcSpan
loc (FunBind { fun_id = (dL->L nm_loc name)
                                , fun_matches = matches }))
  = SrcSpan
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
sig_loc (TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar]))
-> TcM (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall a b. (a -> b) -> a -> b
$
    do { String -> SDoc -> TcRn ()
traceTc "tcPolyCheck" (TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
poly_id SDoc -> SDoc -> SDoc
$$ SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr SrcSpan
sig_loc)
       ; (tv_prs :: [(Name, TyVar)]
tv_prs, theta :: ThetaType
theta, tau :: Type
tau) <- ([TyVar] -> TcM (TCvSubst, [TyVar]))
-> TyVar -> TcM ([(Name, TyVar)], ThetaType, Type)
tcInstType [TyVar] -> TcM (TCvSubst, [TyVar])
tcInstSkolTyVars TyVar
poly_id
                -- See Note [Instantiate sig with fresh variables]

       ; Name
mono_name <- OccName -> SrcSpan -> TcM Name
newNameAt (Name -> OccName
nameOccName Name
SrcSpanLess (Located Name)
name) SrcSpan
nm_loc
       ; [TyVar]
ev_vars   <- ThetaType -> TcM [TyVar]
newEvVars ThetaType
theta
       ; let mono_id :: TyVar
mono_id   = Name -> Type -> TyVar
mkLocalId Name
mono_name Type
tau
             skol_info :: SkolemInfo
skol_info = UserTypeCtxt -> Type -> [(Name, TyVar)] -> SkolemInfo
SigSkol UserTypeCtxt
ctxt (TyVar -> Type
idType TyVar
poly_id) [(Name, TyVar)]
tv_prs
             skol_tvs :: [TyVar]
skol_tvs  = ((Name, TyVar) -> TyVar) -> [(Name, TyVar)] -> [TyVar]
forall a b. (a -> b) -> [a] -> [b]
map (Name, TyVar) -> TyVar
forall a b. (a, b) -> b
snd [(Name, TyVar)]
tv_prs

       ; (ev_binds :: TcEvBinds
ev_binds, (co_fn :: HsWrapper
co_fn, matches' :: MatchGroup GhcTc (LHsExpr GhcTc)
matches'))
            <- SkolemInfo
-> [TyVar]
-> [TyVar]
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (TcEvBinds, (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
forall result.
SkolemInfo
-> [TyVar] -> [TyVar] -> TcM result -> TcM (TcEvBinds, result)
checkConstraints SkolemInfo
skol_info [TyVar]
skol_tvs [TyVar]
ev_vars (TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
 -> TcM (TcEvBinds, (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (TcEvBinds, (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
forall a b. (a -> b) -> a -> b
$
               [TcBinder]
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a. [TcBinder] -> TcM a -> TcM a
tcExtendBinderStack [TyVar -> TopLevelFlag -> TcBinder
TcIdBndr TyVar
mono_id TopLevelFlag
NotTopLevel]  (TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
 -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a b. (a -> b) -> a -> b
$
               [(Name, TyVar)]
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall r. [(Name, TyVar)] -> TcM r -> TcM r
tcExtendNameTyVarEnv [(Name, TyVar)]
tv_prs (TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
 -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a b. (a -> b) -> a -> b
$
               SrcSpan
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
loc           (TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
 -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a b. (a -> b) -> a -> b
$
               Located Name
-> MatchGroup GhcRn (LHsExpr GhcRn)
-> ExpRhoType
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
tcMatchesFun (SrcSpan -> SrcSpanLess (Located Name) -> Located Name
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
nm_loc Name
SrcSpanLess (Located Name)
mono_name) MatchGroup GhcRn (LHsExpr GhcRn)
matches (Type -> ExpRhoType
mkCheckExpType Type
tau)

       ; let prag_sigs :: [LSig GhcRn]
prag_sigs = TcPragEnv -> Name -> [LSig GhcRn]
lookupPragEnv TcPragEnv
prag_fn Name
SrcSpanLess (Located Name)
name
       ; [LTcSpecPrag]
spec_prags <- TyVar -> [LSig GhcRn] -> TcM [LTcSpecPrag]
tcSpecPrags TyVar
poly_id [LSig GhcRn]
prag_sigs
       ; TyVar
poly_id    <- TyVar -> [LSig GhcRn] -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
addInlinePrags TyVar
poly_id [LSig GhcRn]
prag_sigs

       ; Module
mod <- IOEnv (Env TcGblEnv TcLclEnv) Module
forall (m :: * -> *). HasModule m => m Module
getModule
       ; [Tickish TyVar]
tick <- SrcSpan -> TyVar -> Module -> [LSig GhcRn] -> TcM [Tickish TyVar]
funBindTicks SrcSpan
nm_loc TyVar
mono_id Module
mod [LSig GhcRn]
prag_sigs
       ; let bind' :: HsBindLR GhcTc GhcTc
bind' = FunBind :: forall idL idR.
XFunBind idL idR
-> Located (IdP idL)
-> MatchGroup idR (LHsExpr idR)
-> HsWrapper
-> [Tickish TyVar]
-> HsBindLR idL idR
FunBind { fun_id :: Located (IdP GhcTc)
fun_id      = SrcSpan -> SrcSpanLess (Located TyVar) -> Located TyVar
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
nm_loc SrcSpanLess (Located TyVar)
TyVar
mono_id
                             , fun_matches :: MatchGroup GhcTc (LHsExpr GhcTc)
fun_matches = MatchGroup GhcTc (LHsExpr GhcTc)
matches'
                             , fun_co_fn :: HsWrapper
fun_co_fn   = HsWrapper
co_fn
                             , fun_ext :: XFunBind GhcTc GhcTc
fun_ext     = UniqSet Name
XFunBind GhcTc GhcTc
placeHolderNamesTc
                             , fun_tick :: [Tickish TyVar]
fun_tick    = [Tickish TyVar]
tick }

             export :: ABExport GhcTc
export = ABE :: forall p.
XABE p -> IdP p -> IdP p -> HsWrapper -> TcSpecPrags -> ABExport p
ABE { abe_ext :: XABE GhcTc
abe_ext = XABE GhcTc
NoExt
noExt
                          , abe_wrap :: HsWrapper
abe_wrap = HsWrapper
idHsWrapper
                          , abe_poly :: IdP GhcTc
abe_poly  = TyVar
IdP GhcTc
poly_id
                          , abe_mono :: IdP GhcTc
abe_mono  = TyVar
IdP GhcTc
mono_id
                          , abe_prags :: TcSpecPrags
abe_prags = [LTcSpecPrag] -> TcSpecPrags
SpecPrags [LTcSpecPrag]
spec_prags }

             abs_bind :: LHsBindLR GhcTc GhcTc
abs_bind = SrcSpan
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc (SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc)
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a b. (a -> b) -> a -> b
$
                        AbsBinds :: forall idL idR.
XAbsBinds idL idR
-> [TyVar]
-> [TyVar]
-> [ABExport idL]
-> [TcEvBinds]
-> LHsBinds idL
-> Bool
-> HsBindLR idL idR
AbsBinds { abs_ext :: XAbsBinds GhcTc GhcTc
abs_ext = XAbsBinds GhcTc GhcTc
NoExt
noExt
                                 , abs_tvs :: [TyVar]
abs_tvs      = [TyVar]
skol_tvs
                                 , abs_ev_vars :: [TyVar]
abs_ev_vars  = [TyVar]
ev_vars
                                 , abs_ev_binds :: [TcEvBinds]
abs_ev_binds = [TcEvBinds
ev_binds]
                                 , abs_exports :: [ABExport GhcTc]
abs_exports  = [ABExport GhcTc
export]
                                 , abs_binds :: LHsBinds GhcTc
abs_binds    = LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc
forall a. a -> Bag a
unitBag (SrcSpan
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc SrcSpanLess (LHsBindLR GhcTc GhcTc)
HsBindLR GhcTc GhcTc
bind')
                                 , abs_sig :: Bool
abs_sig      = Bool
True }

       ; (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc
forall a. a -> Bag a
unitBag LHsBindLR GhcTc GhcTc
abs_bind, [TyVar
poly_id]) }

tcPolyCheck _prag_fn :: TcPragEnv
_prag_fn sig :: TcIdSigInfo
sig bind :: LHsBindLR GhcRn GhcRn
bind
  = String -> SDoc -> TcM (LHsBinds GhcTc, [TyVar])
forall a. HasCallStack => String -> SDoc -> a
pprPanic "tcPolyCheck" (TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
sig SDoc -> SDoc -> SDoc
$$ LHsBindLR GhcRn GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsBindLR GhcRn GhcRn
bind)

funBindTicks :: SrcSpan -> TcId -> Module -> [LSig GhcRn]
             -> TcM [Tickish TcId]
funBindTicks :: SrcSpan -> TyVar -> Module -> [LSig GhcRn] -> TcM [Tickish TyVar]
funBindTicks loc :: SrcSpan
loc fun_id :: TyVar
fun_id mod :: Module
mod sigs :: [LSig GhcRn]
sigs
  | (mb_cc_str :: Maybe (Located StringLiteral)
mb_cc_str : _) <- [ Maybe (Located StringLiteral)
cc_name | (LSig GhcRn -> Located (SrcSpanLess (LSig GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ (SCCFunSig _ _ _ cc_name)) <- [LSig GhcRn]
sigs ]
      -- this can only be a singleton list, as duplicate pragmas are rejected
      -- by the renamer
  , let cc_str :: FastString
cc_str
          | Just cc_str :: Located StringLiteral
cc_str <- Maybe (Located StringLiteral)
mb_cc_str
          = StringLiteral -> FastString
sl_fs (StringLiteral -> FastString) -> StringLiteral -> FastString
forall a b. (a -> b) -> a -> b
$ Located StringLiteral -> SrcSpanLess (Located StringLiteral)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located StringLiteral
cc_str
          | Bool
otherwise
          = Name -> FastString
forall a. NamedThing a => a -> FastString
getOccFS (TyVar -> Name
Var.varName TyVar
fun_id)
        cc_name :: FastString
cc_name = ModuleName -> FastString
moduleNameFS (Module -> ModuleName
moduleName Module
mod) FastString -> FastString -> FastString
`appendFS` Char -> FastString -> FastString
consFS '.' FastString
cc_str
  = do
      CCFlavour
flavour <- CostCentreIndex -> CCFlavour
DeclCC (CostCentreIndex -> CCFlavour)
-> IOEnv (Env TcGblEnv TcLclEnv) CostCentreIndex
-> IOEnv (Env TcGblEnv TcLclEnv) CCFlavour
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FastString -> IOEnv (Env TcGblEnv TcLclEnv) CostCentreIndex
forall gbl lcl.
ContainsCostCentreState gbl =>
FastString -> TcRnIf gbl lcl CostCentreIndex
getCCIndexM FastString
cc_name
      let cc :: CostCentre
cc = FastString -> Module -> SrcSpan -> CCFlavour -> CostCentre
mkUserCC FastString
cc_name Module
mod SrcSpan
loc CCFlavour
flavour
      [Tickish TyVar] -> TcM [Tickish TyVar]
forall (m :: * -> *) a. Monad m => a -> m a
return [CostCentre -> Bool -> Bool -> Tickish TyVar
forall id. CostCentre -> Bool -> Bool -> Tickish id
ProfNote CostCentre
cc Bool
True Bool
True]
  | Bool
otherwise
  = [Tickish TyVar] -> TcM [Tickish TyVar]
forall (m :: * -> *) a. Monad m => a -> m a
return []

{- Note [Instantiate sig with fresh variables]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It's vital to instantiate a type signature with fresh variables.
For example:
      type T = forall a. [a] -> [a]
      f :: T;
      f = g where { g :: T; g = <rhs> }

 We must not use the same 'a' from the defn of T at both places!!
(Instantiation is only necessary because of type synonyms.  Otherwise,
it's all cool; each signature has distinct type variables from the renamer.)
-}


{- *********************************************************************
*                                                                      *
                         tcPolyInfer
*                                                                      *
********************************************************************* -}

tcPolyInfer
  :: RecFlag       -- Whether it's recursive after breaking
                   -- dependencies based on type signatures
  -> TcPragEnv -> TcSigFun
  -> Bool         -- True <=> apply the monomorphism restriction
  -> [LHsBind GhcRn]
  -> TcM (LHsBinds GhcTcId, [TcId])
tcPolyInfer :: RecFlag
-> TcPragEnv
-> TcSigFun
-> Bool
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [TyVar])
tcPolyInfer rec_tc :: RecFlag
rec_tc prag_fn :: TcPragEnv
prag_fn tc_sig_fn :: TcSigFun
tc_sig_fn mono :: Bool
mono bind_list :: [LHsBindLR GhcRn GhcRn]
bind_list
  = do { (tclvl :: TcLevel
tclvl, wanted :: WantedConstraints
wanted, (binds' :: LHsBinds GhcTc
binds', mono_infos :: [MonoBindInfo]
mono_infos))
             <- TcM (LHsBinds GhcTc, [MonoBindInfo])
-> TcM
     (TcLevel, WantedConstraints, (LHsBinds GhcTc, [MonoBindInfo]))
forall a. TcM a -> TcM (TcLevel, WantedConstraints, a)
pushLevelAndCaptureConstraints  (TcM (LHsBinds GhcTc, [MonoBindInfo])
 -> TcM
      (TcLevel, WantedConstraints, (LHsBinds GhcTc, [MonoBindInfo])))
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
-> TcM
     (TcLevel, WantedConstraints, (LHsBinds GhcTc, [MonoBindInfo]))
forall a b. (a -> b) -> a -> b
$
                RecFlag
-> TcSigFun
-> LetBndrSpec
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
tcMonoBinds RecFlag
rec_tc TcSigFun
tc_sig_fn LetBndrSpec
LetLclBndr [LHsBindLR GhcRn GhcRn]
bind_list

       ; let name_taus :: [(Name, Type)]
name_taus  = [ (MonoBindInfo -> Name
mbi_poly_name MonoBindInfo
info, TyVar -> Type
idType (MonoBindInfo -> TyVar
mbi_mono_id MonoBindInfo
info))
                          | MonoBindInfo
info <- [MonoBindInfo]
mono_infos ]
             sigs :: [TcIdSigInst]
sigs       = [ TcIdSigInst
sig | MBI { mbi_sig :: MonoBindInfo -> Maybe TcIdSigInst
mbi_sig = Just sig :: TcIdSigInst
sig } <- [MonoBindInfo]
mono_infos ]
             infer_mode :: InferMode
infer_mode = if Bool
mono then InferMode
ApplyMR else InferMode
NoRestrictions

       ; (TcIdSigInst -> TcRn ()) -> [TcIdSigInst] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Bool -> TcIdSigInst -> TcRn ()
checkOverloadedSig Bool
mono) [TcIdSigInst]
sigs

       ; String -> SDoc -> TcRn ()
traceTc "simplifyInfer call" (TcLevel -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcLevel
tclvl SDoc -> SDoc -> SDoc
$$ [(Name, Type)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(Name, Type)]
name_taus SDoc -> SDoc -> SDoc
$$ WantedConstraints -> SDoc
forall a. Outputable a => a -> SDoc
ppr WantedConstraints
wanted)
       ; (qtvs :: [TyVar]
qtvs, givens :: [TyVar]
givens, ev_binds :: TcEvBinds
ev_binds, residual :: WantedConstraints
residual, insoluble :: Bool
insoluble)
                 <- TcLevel
-> InferMode
-> [TcIdSigInst]
-> [(Name, Type)]
-> WantedConstraints
-> TcM ([TyVar], [TyVar], TcEvBinds, WantedConstraints, Bool)
simplifyInfer TcLevel
tclvl InferMode
infer_mode [TcIdSigInst]
sigs [(Name, Type)]
name_taus WantedConstraints
wanted
       ; WantedConstraints -> TcRn ()
emitConstraints WantedConstraints
residual

       ; let inferred_theta :: ThetaType
inferred_theta = (TyVar -> Type) -> [TyVar] -> ThetaType
forall a b. (a -> b) -> [a] -> [b]
map TyVar -> Type
evVarPred [TyVar]
givens
       ; [ABExport GhcTc]
exports <- TcM [ABExport GhcTc] -> TcM [ABExport GhcTc]
forall r. TcM r -> TcM r
checkNoErrs (TcM [ABExport GhcTc] -> TcM [ABExport GhcTc])
-> TcM [ABExport GhcTc] -> TcM [ABExport GhcTc]
forall a b. (a -> b) -> a -> b
$
                    (MonoBindInfo -> IOEnv (Env TcGblEnv TcLclEnv) (ABExport GhcTc))
-> [MonoBindInfo] -> TcM [ABExport GhcTc]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (TcPragEnv
-> Bool
-> [TyVar]
-> ThetaType
-> MonoBindInfo
-> IOEnv (Env TcGblEnv TcLclEnv) (ABExport GhcTc)
mkExport TcPragEnv
prag_fn Bool
insoluble [TyVar]
qtvs ThetaType
inferred_theta) [MonoBindInfo]
mono_infos

       ; SrcSpan
loc <- TcRn SrcSpan
getSrcSpanM
       ; let poly_ids :: [TyVar]
poly_ids = (ABExport GhcTc -> TyVar) -> [ABExport GhcTc] -> [TyVar]
forall a b. (a -> b) -> [a] -> [b]
map ABExport GhcTc -> TyVar
forall p. ABExport p -> IdP p
abe_poly [ABExport GhcTc]
exports
             abs_bind :: LHsBindLR GhcTc GhcTc
abs_bind = SrcSpan
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc (SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc)
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a b. (a -> b) -> a -> b
$
                        AbsBinds :: forall idL idR.
XAbsBinds idL idR
-> [TyVar]
-> [TyVar]
-> [ABExport idL]
-> [TcEvBinds]
-> LHsBinds idL
-> Bool
-> HsBindLR idL idR
AbsBinds { abs_ext :: XAbsBinds GhcTc GhcTc
abs_ext = XAbsBinds GhcTc GhcTc
NoExt
noExt
                                 , abs_tvs :: [TyVar]
abs_tvs = [TyVar]
qtvs
                                 , abs_ev_vars :: [TyVar]
abs_ev_vars = [TyVar]
givens, abs_ev_binds :: [TcEvBinds]
abs_ev_binds = [TcEvBinds
ev_binds]
                                 , abs_exports :: [ABExport GhcTc]
abs_exports = [ABExport GhcTc]
exports, abs_binds :: LHsBinds GhcTc
abs_binds = LHsBinds GhcTc
binds'
                                 , abs_sig :: Bool
abs_sig = Bool
False }

       ; String -> SDoc -> TcRn ()
traceTc "Binding:" ([(TyVar, Type)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr ([TyVar]
poly_ids [TyVar] -> ThetaType -> [(TyVar, Type)]
forall a b. [a] -> [b] -> [(a, b)]
`zip` (TyVar -> Type) -> [TyVar] -> ThetaType
forall a b. (a -> b) -> [a] -> [b]
map TyVar -> Type
idType [TyVar]
poly_ids))
       ; (LHsBinds GhcTc, [TyVar]) -> TcM (LHsBinds GhcTc, [TyVar])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc
forall a. a -> Bag a
unitBag LHsBindLR GhcTc GhcTc
abs_bind, [TyVar]
poly_ids) }
         -- poly_ids are guaranteed zonked by mkExport

--------------
mkExport :: TcPragEnv
         -> Bool                        -- True <=> there was an insoluble type error
                                        --          when typechecking the bindings
         -> [TyVar] -> TcThetaType      -- Both already zonked
         -> MonoBindInfo
         -> TcM (ABExport GhcTc)
-- Only called for generalisation plan InferGen, not by CheckGen or NoGen
--
-- mkExport generates exports with
--      zonked type variables,
--      zonked poly_ids
-- The former is just because no further unifications will change
-- the quantified type variables, so we can fix their final form
-- right now.
-- The latter is needed because the poly_ids are used to extend the
-- type environment; see the invariant on TcEnv.tcExtendIdEnv

-- Pre-condition: the qtvs and theta are already zonked

mkExport :: TcPragEnv
-> Bool
-> [TyVar]
-> ThetaType
-> MonoBindInfo
-> IOEnv (Env TcGblEnv TcLclEnv) (ABExport GhcTc)
mkExport prag_fn :: TcPragEnv
prag_fn insoluble :: Bool
insoluble qtvs :: [TyVar]
qtvs theta :: ThetaType
theta
         mono_info :: MonoBindInfo
mono_info@(MBI { mbi_poly_name :: MonoBindInfo -> Name
mbi_poly_name = Name
poly_name
                        , mbi_sig :: MonoBindInfo -> Maybe TcIdSigInst
mbi_sig       = Maybe TcIdSigInst
mb_sig
                        , mbi_mono_id :: MonoBindInfo -> TyVar
mbi_mono_id   = TyVar
mono_id })
  = do  { Type
mono_ty <- Type -> TcM Type
zonkTcType (TyVar -> Type
idType TyVar
mono_id)
        ; TyVar
poly_id <- Bool
-> [TyVar]
-> ThetaType
-> Name
-> Maybe TcIdSigInst
-> Type
-> IOEnv (Env TcGblEnv TcLclEnv) TyVar
mkInferredPolyId Bool
insoluble [TyVar]
qtvs ThetaType
theta Name
poly_name Maybe TcIdSigInst
mb_sig Type
mono_ty

        -- NB: poly_id has a zonked type
        ; TyVar
poly_id <- TyVar -> [LSig GhcRn] -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
addInlinePrags TyVar
poly_id [LSig GhcRn]
prag_sigs
        ; [LTcSpecPrag]
spec_prags <- TyVar -> [LSig GhcRn] -> TcM [LTcSpecPrag]
tcSpecPrags TyVar
poly_id [LSig GhcRn]
prag_sigs
                -- tcPrags requires a zonked poly_id

        -- See Note [Impedance matching]
        -- NB: we have already done checkValidType, including an ambiguity check,
        --     on the type; either when we checked the sig or in mkInferredPolyId
        ; let poly_ty :: Type
poly_ty     = TyVar -> Type
idType TyVar
poly_id
              sel_poly_ty :: Type
sel_poly_ty = [TyVar] -> ThetaType -> Type -> Type
mkInfSigmaTy [TyVar]
qtvs ThetaType
theta Type
mono_ty
                -- This type is just going into tcSubType,
                -- so Inferred vs. Specified doesn't matter

        ; HsWrapper
wrap <- if Type
sel_poly_ty Type -> Type -> Bool
`eqType` Type
poly_ty  -- NB: eqType ignores visibility
                  then HsWrapper -> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
forall (m :: * -> *) a. Monad m => a -> m a
return HsWrapper
idHsWrapper  -- Fast path; also avoids complaint when we infer
                                           -- an ambiguous type and have AllowAmbiguousType
                                           -- e..g infer  x :: forall a. F a -> Int
                  else (TidyEnv -> TcM (TidyEnv, SDoc))
-> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
-> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
forall a. (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a
addErrCtxtM (MonoBindInfo -> Type -> Type -> TidyEnv -> TcM (TidyEnv, SDoc)
mk_impedance_match_msg MonoBindInfo
mono_info Type
sel_poly_ty Type
poly_ty) (IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
 -> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper)
-> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
-> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
forall a b. (a -> b) -> a -> b
$
                       UserTypeCtxt
-> Type -> Type -> IOEnv (Env TcGblEnv TcLclEnv) HsWrapper
tcSubType_NC UserTypeCtxt
sig_ctxt Type
sel_poly_ty Type
poly_ty

        ; Bool
warn_missing_sigs <- WarningFlag -> TcRnIf TcGblEnv TcLclEnv Bool
forall gbl lcl. WarningFlag -> TcRnIf gbl lcl Bool
woptM WarningFlag
Opt_WarnMissingLocalSignatures
        ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
warn_missing_sigs (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
              WarningFlag -> TyVar -> Maybe TcIdSigInst -> TcRn ()
localSigWarn WarningFlag
Opt_WarnMissingLocalSignatures TyVar
poly_id Maybe TcIdSigInst
mb_sig

        ; ABExport GhcTc -> IOEnv (Env TcGblEnv TcLclEnv) (ABExport GhcTc)
forall (m :: * -> *) a. Monad m => a -> m a
return (ABE :: forall p.
XABE p -> IdP p -> IdP p -> HsWrapper -> TcSpecPrags -> ABExport p
ABE { abe_ext :: XABE GhcTc
abe_ext = XABE GhcTc
NoExt
noExt
                      , abe_wrap :: HsWrapper
abe_wrap = HsWrapper
wrap
                        -- abe_wrap :: idType poly_id ~ (forall qtvs. theta => mono_ty)
                      , abe_poly :: IdP GhcTc
abe_poly  = TyVar
IdP GhcTc
poly_id
                      , abe_mono :: IdP GhcTc
abe_mono  = TyVar
IdP GhcTc
mono_id
                      , abe_prags :: TcSpecPrags
abe_prags = [LTcSpecPrag] -> TcSpecPrags
SpecPrags [LTcSpecPrag]
spec_prags }) }
  where
    prag_sigs :: [LSig GhcRn]
prag_sigs = TcPragEnv -> Name -> [LSig GhcRn]
lookupPragEnv TcPragEnv
prag_fn Name
poly_name
    sig_ctxt :: UserTypeCtxt
sig_ctxt  = Name -> UserTypeCtxt
InfSigCtxt Name
poly_name

mkInferredPolyId :: Bool  -- True <=> there was an insoluble error when
                          --          checking the binding group for this Id
                 -> [TyVar] -> TcThetaType
                 -> Name -> Maybe TcIdSigInst -> TcType
                 -> TcM TcId
mkInferredPolyId :: Bool
-> [TyVar]
-> ThetaType
-> Name
-> Maybe TcIdSigInst
-> Type
-> IOEnv (Env TcGblEnv TcLclEnv) TyVar
mkInferredPolyId insoluble :: Bool
insoluble qtvs :: [TyVar]
qtvs inferred_theta :: ThetaType
inferred_theta poly_name :: Name
poly_name mb_sig_inst :: Maybe TcIdSigInst
mb_sig_inst mono_ty :: Type
mono_ty
  | Just (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSigInfo
sig_inst_sig = TcIdSigInfo
sig })  <- Maybe TcIdSigInst
mb_sig_inst
  , CompleteSig { sig_bndr :: TcIdSigInfo -> TyVar
sig_bndr = TyVar
poly_id } <- TcIdSigInfo
sig
  = TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall (m :: * -> *) a. Monad m => a -> m a
return TyVar
poly_id

  | Bool
otherwise  -- Either no type sig or partial type sig
  = IOEnv (Env TcGblEnv TcLclEnv) TyVar
-> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall r. TcM r -> TcM r
checkNoErrs (IOEnv (Env TcGblEnv TcLclEnv) TyVar
 -> IOEnv (Env TcGblEnv TcLclEnv) TyVar)
-> IOEnv (Env TcGblEnv TcLclEnv) TyVar
-> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall a b. (a -> b) -> a -> b
$  -- The checkNoErrs ensures that if the type is ambiguous
                   -- we don't carry on to the impedance matching, and generate
                   -- a duplicate ambiguity error.  There is a similar
                   -- checkNoErrs for complete type signatures too.
    do { FamInstEnvs
fam_envs <- TcM FamInstEnvs
tcGetFamInstEnvs
       ; let (_co :: TcCoercionR
_co, mono_ty' :: Type
mono_ty') = FamInstEnvs -> Role -> Type -> (TcCoercionR, Type)
normaliseType FamInstEnvs
fam_envs Role
Nominal Type
mono_ty
               -- Unification may not have normalised the type,
               -- (see Note [Lazy flattening] in TcFlatten) so do it
               -- here to make it as uncomplicated as possible.
               -- Example: f :: [F Int] -> Bool
               -- should be rewritten to f :: [Char] -> Bool, if possible
               --
               -- We can discard the coercion _co, because we'll reconstruct
               -- it in the call to tcSubType below

       ; (binders :: [TyVarBinder]
binders, theta' :: ThetaType
theta') <- ThetaType
-> TcTyVarSet
-> [TyVar]
-> Maybe TcIdSigInst
-> TcM ([TyVarBinder], ThetaType)
chooseInferredQuantifiers ThetaType
inferred_theta
                                (Type -> TcTyVarSet
tyCoVarsOfType Type
mono_ty') [TyVar]
qtvs Maybe TcIdSigInst
mb_sig_inst

       ; let inferred_poly_ty :: Type
inferred_poly_ty = [TyVarBinder] -> Type -> Type
mkForAllTys [TyVarBinder]
binders (ThetaType -> Type -> Type
mkPhiTy ThetaType
theta' Type
mono_ty')

       ; String -> SDoc -> TcRn ()
traceTc "mkInferredPolyId" ([SDoc] -> SDoc
vcat [Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
poly_name, [TyVar] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [TyVar]
qtvs, ThetaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThetaType
theta'
                                          , Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
inferred_poly_ty])
       ; Bool -> TcRn () -> TcRn ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
insoluble (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
         (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcRn () -> TcRn ()
forall a. (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a
addErrCtxtM (Name -> Type -> TidyEnv -> TcM (TidyEnv, SDoc)
mk_inf_msg Name
poly_name Type
inferred_poly_ty) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
         UserTypeCtxt -> Type -> TcRn ()
checkValidType (Name -> UserTypeCtxt
InfSigCtxt Name
poly_name) Type
inferred_poly_ty
         -- See Note [Validity of inferred types]
         -- If we found an insoluble error in the function definition, don't
         -- do this check; otherwise (Trac #14000) we may report an ambiguity
         -- error for a rather bogus type.

       ; TyVar -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Type -> TyVar
mkLocalIdOrCoVar Name
poly_name Type
inferred_poly_ty) }


chooseInferredQuantifiers :: TcThetaType   -- inferred
                          -> TcTyVarSet    -- tvs free in tau type
                          -> [TcTyVar]     -- inferred quantified tvs
                          -> Maybe TcIdSigInst
                          -> TcM ([TyVarBinder], TcThetaType)
chooseInferredQuantifiers :: ThetaType
-> TcTyVarSet
-> [TyVar]
-> Maybe TcIdSigInst
-> TcM ([TyVarBinder], ThetaType)
chooseInferredQuantifiers inferred_theta :: ThetaType
inferred_theta tau_tvs :: TcTyVarSet
tau_tvs qtvs :: [TyVar]
qtvs Nothing
  = -- No type signature (partial or complete) for this binder,
    do { let free_tvs :: TcTyVarSet
free_tvs = TcTyVarSet -> TcTyVarSet
closeOverKinds (ThetaType -> TcTyVarSet -> TcTyVarSet
growThetaTyVars ThetaType
inferred_theta TcTyVarSet
tau_tvs)
                        -- Include kind variables!  Trac #7916
             my_theta :: ThetaType
my_theta = TcTyVarSet -> ThetaType -> ThetaType
pickCapturedPreds TcTyVarSet
free_tvs ThetaType
inferred_theta
             binders :: [TyVarBinder]
binders  = [ ArgFlag -> TyVar -> TyVarBinder
mkTyVarBinder ArgFlag
Inferred TyVar
tv
                        | TyVar
tv <- [TyVar]
qtvs
                        , TyVar
tv TyVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
free_tvs ]
       ; ([TyVarBinder], ThetaType) -> TcM ([TyVarBinder], ThetaType)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TyVarBinder]
binders, ThetaType
my_theta) }

chooseInferredQuantifiers inferred_theta :: ThetaType
inferred_theta tau_tvs :: TcTyVarSet
tau_tvs qtvs :: [TyVar]
qtvs
                          (Just (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSigInfo
sig_inst_sig   = TcIdSigInfo
sig  -- Always PartialSig
                                      , sig_inst_wcx :: TcIdSigInst -> Maybe Type
sig_inst_wcx   = Maybe Type
wcx
                                      , sig_inst_theta :: TcIdSigInst -> ThetaType
sig_inst_theta = ThetaType
annotated_theta
                                      , sig_inst_skols :: TcIdSigInst -> [(Name, TyVar)]
sig_inst_skols = [(Name, TyVar)]
annotated_tvs }))
  = -- Choose quantifiers for a partial type signature
    do { [(Name, TyVar)]
psig_qtv_prs <- [(Name, TyVar)] -> TcM [(Name, TyVar)]
zonkTyVarTyVarPairs [(Name, TyVar)]
annotated_tvs

            -- Check whether the quantified variables of the
            -- partial signature have been unified together
            -- See Note [Quantified variables in partial type signatures]
       ; ((Name, Name) -> TcRn ()) -> [(Name, Name)] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (Name, Name) -> TcRn ()
report_dup_tyvar_tv_err  ([(Name, TyVar)] -> [(Name, Name)]
findDupTyVarTvs [(Name, TyVar)]
psig_qtv_prs)

            -- Check whether a quantified variable of the partial type
            -- signature is not actually quantified.  How can that happen?
            -- See Note [Quantification and partial signatures] Wrinkle 4
            --     in TcSimplify
       ; (Name -> TcRn ()) -> [Name] -> TcRn ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Name -> TcRn ()
report_mono_sig_tv_err [ Name
n | (n :: Name
n,tv :: TyVar
tv) <- [(Name, TyVar)]
psig_qtv_prs
                                          , Bool -> Bool
not (TyVar
tv TyVar -> [TyVar] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [TyVar]
qtvs) ]

       ; let psig_qtvs :: TcTyVarSet
psig_qtvs = [TyVar] -> TcTyVarSet
mkVarSet (((Name, TyVar) -> TyVar) -> [(Name, TyVar)] -> [TyVar]
forall a b. (a -> b) -> [a] -> [b]
map (Name, TyVar) -> TyVar
forall a b. (a, b) -> b
snd [(Name, TyVar)]
psig_qtv_prs)

       ; ThetaType
annotated_theta      <- ThetaType -> TcM ThetaType
zonkTcTypes ThetaType
annotated_theta
       ; (free_tvs :: TcTyVarSet
free_tvs, my_theta :: ThetaType
my_theta) <- TcTyVarSet
-> ThetaType -> Maybe Type -> TcM (TcTyVarSet, ThetaType)
choose_psig_context TcTyVarSet
psig_qtvs ThetaType
annotated_theta Maybe Type
wcx

       ; let keep_me :: TcTyVarSet
keep_me    = TcTyVarSet
free_tvs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
psig_qtvs
             final_qtvs :: [TyVarBinder]
final_qtvs = [ ArgFlag -> TyVar -> TyVarBinder
mkTyVarBinder ArgFlag
vis TyVar
tv
                          | TyVar
tv <- [TyVar]
qtvs -- Pulling from qtvs maintains original order
                          , TyVar
tv TyVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
keep_me
                          , let vis :: ArgFlag
vis | TyVar
tv TyVar -> TcTyVarSet -> Bool
`elemVarSet` TcTyVarSet
psig_qtvs = ArgFlag
Specified
                                    | Bool
otherwise                 = ArgFlag
Inferred ]

       ; ([TyVarBinder], ThetaType) -> TcM ([TyVarBinder], ThetaType)
forall (m :: * -> *) a. Monad m => a -> m a
return ([TyVarBinder]
final_qtvs, ThetaType
my_theta) }
  where
    report_dup_tyvar_tv_err :: (Name, Name) -> TcRn ()
report_dup_tyvar_tv_err (n1 :: Name
n1,n2 :: Name
n2)
      | PartialSig { psig_name :: TcIdSigInfo -> Name
psig_name = Name
fn_name, psig_hs_ty :: TcIdSigInfo -> LHsSigWcType GhcRn
psig_hs_ty = LHsSigWcType GhcRn
hs_ty } <- TcIdSigInfo
sig
      = SDoc -> TcRn ()
addErrTc (SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "Couldn't match" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n1)
                        SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "with" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n2))
                     2 (SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "both bound by the partial type signature:")
                           2 (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
fn_name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> LHsSigWcType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigWcType GhcRn
hs_ty)))

      | Bool
otherwise -- Can't happen; by now we know it's a partial sig
      = String -> SDoc -> TcRn ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic "report_tyvar_tv_err" (TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
sig)

    report_mono_sig_tv_err :: Name -> TcRn ()
report_mono_sig_tv_err n :: Name
n
      | PartialSig { psig_name :: TcIdSigInfo -> Name
psig_name = Name
fn_name, psig_hs_ty :: TcIdSigInfo -> LHsSigWcType GhcRn
psig_hs_ty = LHsSigWcType GhcRn
hs_ty } <- TcIdSigInfo
sig
      = SDoc -> TcRn ()
addErrTc (SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "Can't quantify over" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n))
                     2 (SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "bound by the partial type signature:")
                           2 (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
fn_name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> LHsSigWcType GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr LHsSigWcType GhcRn
hs_ty)))
      | Bool
otherwise -- Can't happen; by now we know it's a partial sig
      = String -> SDoc -> TcRn ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic "report_mono_sig_tv_err" (TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
sig)

    choose_psig_context :: VarSet -> TcThetaType -> Maybe TcType
                        -> TcM (VarSet, TcThetaType)
    choose_psig_context :: TcTyVarSet
-> ThetaType -> Maybe Type -> TcM (TcTyVarSet, ThetaType)
choose_psig_context _ annotated_theta :: ThetaType
annotated_theta Nothing
      = do { let free_tvs :: TcTyVarSet
free_tvs = TcTyVarSet -> TcTyVarSet
closeOverKinds (ThetaType -> TcTyVarSet
tyCoVarsOfTypes ThetaType
annotated_theta
                                            TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
tau_tvs)
           ; (TcTyVarSet, ThetaType) -> TcM (TcTyVarSet, ThetaType)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcTyVarSet
free_tvs, ThetaType
annotated_theta) }

    choose_psig_context psig_qtvs :: TcTyVarSet
psig_qtvs annotated_theta :: ThetaType
annotated_theta (Just wc_var_ty :: Type
wc_var_ty)
      = do { let free_tvs :: TcTyVarSet
free_tvs = TcTyVarSet -> TcTyVarSet
closeOverKinds (ThetaType -> TcTyVarSet -> TcTyVarSet
growThetaTyVars ThetaType
inferred_theta TcTyVarSet
seed_tvs)
                            -- growThetaVars just like the no-type-sig case
                            -- Omitting this caused #12844
                 seed_tvs :: TcTyVarSet
seed_tvs = ThetaType -> TcTyVarSet
tyCoVarsOfTypes ThetaType
annotated_theta  -- These are put there
                            TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
tau_tvs            --       by the user

           ; let keep_me :: TcTyVarSet
keep_me  = TcTyVarSet
psig_qtvs TcTyVarSet -> TcTyVarSet -> TcTyVarSet
`unionVarSet` TcTyVarSet
free_tvs
                 my_theta :: ThetaType
my_theta = TcTyVarSet -> ThetaType -> ThetaType
pickCapturedPreds TcTyVarSet
keep_me ThetaType
inferred_theta

           -- Fill in the extra-constraints wildcard hole with inferred_theta,
           -- so that the Hole constraint we have already emitted
           -- (in tcHsPartialSigType) can report what filled it in.
           -- NB: my_theta already includes all the annotated constraints
           ; let inferred_diff :: ThetaType
inferred_diff = [ Type
pred
                                 | Type
pred <- ThetaType
my_theta
                                 , (Type -> Bool) -> ThetaType -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Bool -> Bool
not (Bool -> Bool) -> (Type -> Bool) -> Type -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Type -> Type -> Bool
`eqType` Type
pred)) ThetaType
annotated_theta ]
           ; Type
ctuple <- ThetaType -> TcM Type
forall (m :: * -> *). Monad m => ThetaType -> m Type
mk_ctuple ThetaType
inferred_diff

           ; case Type -> Maybe (TyVar, TcCoercionR)
tcGetCastedTyVar_maybe Type
wc_var_ty of
               -- We know that wc_co must have type kind(wc_var) ~ Constraint, as it
               -- comes from the checkExpectedKind in TcHsType.tcWildCardOcc. So, to
               -- make the kinds work out, we reverse the cast here.
               Just (wc_var :: TyVar
wc_var, wc_co :: TcCoercionR
wc_co) -> TyVar -> Type -> TcRn ()
writeMetaTyVar TyVar
wc_var (Type
ctuple Type -> TcCoercionR -> Type
`mkCastTy` TcCoercionR -> TcCoercionR
mkTcSymCo TcCoercionR
wc_co)
               Nothing              -> String -> SDoc -> TcRn ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic "chooseInferredQuantifiers 1" (Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
wc_var_ty)

           ; String -> SDoc -> TcRn ()
traceTc "completeTheta" (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$
                [SDoc] -> SDoc
vcat [ TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
sig
                     , ThetaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThetaType
annotated_theta, ThetaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThetaType
inferred_theta
                     , ThetaType -> SDoc
forall a. Outputable a => a -> SDoc
ppr ThetaType
inferred_diff ]
           ; (TcTyVarSet, ThetaType) -> TcM (TcTyVarSet, ThetaType)
forall (m :: * -> *) a. Monad m => a -> m a
return (TcTyVarSet
free_tvs, ThetaType
my_theta) }

    mk_ctuple :: ThetaType -> m Type
mk_ctuple preds :: ThetaType
preds = Type -> m Type
forall (m :: * -> *) a. Monad m => a -> m a
return (ThetaType -> Type
mkBoxedTupleTy ThetaType
preds)
       -- Hack alert!  See TcHsType:
       -- Note [Extra-constraint holes in partial type signatures]


mk_impedance_match_msg :: MonoBindInfo
                       -> TcType -> TcType
                       -> TidyEnv -> TcM (TidyEnv, SDoc)
-- This is a rare but rather awkward error messages
mk_impedance_match_msg :: MonoBindInfo -> Type -> Type -> TidyEnv -> TcM (TidyEnv, SDoc)
mk_impedance_match_msg (MBI { mbi_poly_name :: MonoBindInfo -> Name
mbi_poly_name = Name
name, mbi_sig :: MonoBindInfo -> Maybe TcIdSigInst
mbi_sig = Maybe TcIdSigInst
mb_sig })
                       inf_ty :: Type
inf_ty sig_ty :: Type
sig_ty tidy_env :: TidyEnv
tidy_env
 = do { (tidy_env1 :: TidyEnv
tidy_env1, inf_ty :: Type
inf_ty) <- TidyEnv -> Type -> TcM (TidyEnv, Type)
zonkTidyTcType TidyEnv
tidy_env  Type
inf_ty
      ; (tidy_env2 :: TidyEnv
tidy_env2, sig_ty :: Type
sig_ty) <- TidyEnv -> Type -> TcM (TidyEnv, Type)
zonkTidyTcType TidyEnv
tidy_env1 Type
sig_ty
      ; let msg :: SDoc
msg = [SDoc] -> SDoc
vcat [ String -> SDoc
text "When checking that the inferred type"
                       , BKey -> SDoc -> SDoc
nest 2 (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
inf_ty
                       , String -> SDoc
text "is as general as its" SDoc -> SDoc -> SDoc
<+> SDoc
what SDoc -> SDoc -> SDoc
<+> String -> SDoc
text "signature"
                       , BKey -> SDoc -> SDoc
nest 2 (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
sig_ty ]
      ; (TidyEnv, SDoc) -> TcM (TidyEnv, SDoc)
forall (m :: * -> *) a. Monad m => a -> m a
return (TidyEnv
tidy_env2, SDoc
msg) }
  where
    what :: SDoc
what = case Maybe TcIdSigInst
mb_sig of
             Nothing                     -> String -> SDoc
text "inferred"
             Just sig :: TcIdSigInst
sig | TcIdSigInst -> Bool
isPartialSig TcIdSigInst
sig -> String -> SDoc
text "(partial)"
                      | Bool
otherwise        -> SDoc
empty


mk_inf_msg :: Name -> TcType -> TidyEnv -> TcM (TidyEnv, SDoc)
mk_inf_msg :: Name -> Type -> TidyEnv -> TcM (TidyEnv, SDoc)
mk_inf_msg poly_name :: Name
poly_name poly_ty :: Type
poly_ty tidy_env :: TidyEnv
tidy_env
 = do { (tidy_env1 :: TidyEnv
tidy_env1, poly_ty :: Type
poly_ty) <- TidyEnv -> Type -> TcM (TidyEnv, Type)
zonkTidyTcType TidyEnv
tidy_env Type
poly_ty
      ; let msg :: SDoc
msg = [SDoc] -> SDoc
vcat [ String -> SDoc
text "When checking the inferred type"
                       , BKey -> SDoc -> SDoc
nest 2 (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
poly_name SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
poly_ty ]
      ; (TidyEnv, SDoc) -> TcM (TidyEnv, SDoc)
forall (m :: * -> *) a. Monad m => a -> m a
return (TidyEnv
tidy_env1, SDoc
msg) }


-- | Warn the user about polymorphic local binders that lack type signatures.
localSigWarn :: WarningFlag -> Id -> Maybe TcIdSigInst -> TcM ()
localSigWarn :: WarningFlag -> TyVar -> Maybe TcIdSigInst -> TcRn ()
localSigWarn flag :: WarningFlag
flag id :: TyVar
id mb_sig :: Maybe TcIdSigInst
mb_sig
  | Just _ <- Maybe TcIdSigInst
mb_sig               = () -> TcRn ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  | Bool -> Bool
not (Type -> Bool
isSigmaTy (TyVar -> Type
idType TyVar
id))    = () -> TcRn ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  | Bool
otherwise                      = WarningFlag -> SDoc -> TyVar -> TcRn ()
warnMissingSignatures WarningFlag
flag SDoc
msg TyVar
id
  where
    msg :: SDoc
msg = String -> SDoc
text "Polymorphic local binding with no type signature:"

warnMissingSignatures :: WarningFlag -> SDoc -> Id -> TcM ()
warnMissingSignatures :: WarningFlag -> SDoc -> TyVar -> TcRn ()
warnMissingSignatures flag :: WarningFlag
flag msg :: SDoc
msg id :: TyVar
id
  = do  { TidyEnv
env0 <- TcM TidyEnv
tcInitTidyEnv
        ; let (env1 :: TidyEnv
env1, tidy_ty :: Type
tidy_ty) = TidyEnv -> Type -> (TidyEnv, Type)
tidyOpenType TidyEnv
env0 (TyVar -> Type
idType TyVar
id)
        ; WarnReason -> (TidyEnv, SDoc) -> TcRn ()
addWarnTcM (WarningFlag -> WarnReason
Reason WarningFlag
flag) (TidyEnv
env1, Type -> SDoc
mk_msg Type
tidy_ty) }
  where
    mk_msg :: Type -> SDoc
mk_msg ty :: Type
ty = [SDoc] -> SDoc
sep [ SDoc
msg, BKey -> SDoc -> SDoc
nest 2 (SDoc -> SDoc) -> SDoc -> SDoc
forall a b. (a -> b) -> a -> b
$ Name -> SDoc
forall a. NamedThing a => a -> SDoc
pprPrefixName (TyVar -> Name
idName TyVar
id) SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
ty ]

checkOverloadedSig :: Bool -> TcIdSigInst -> TcM ()
-- Example:
--   f :: Eq a => a -> a
--   K f = e
-- The MR applies, but the signature is overloaded, and it's
-- best to complain about this directly
-- c.f Trac #11339
checkOverloadedSig :: Bool -> TcIdSigInst -> TcRn ()
checkOverloadedSig monomorphism_restriction_applies :: Bool
monomorphism_restriction_applies sig :: TcIdSigInst
sig
  | Bool -> Bool
not (ThetaType -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (TcIdSigInst -> ThetaType
sig_inst_theta TcIdSigInst
sig))
  , Bool
monomorphism_restriction_applies
  , let orig_sig :: TcIdSigInfo
orig_sig = TcIdSigInst -> TcIdSigInfo
sig_inst_sig TcIdSigInst
sig
  = SrcSpan -> TcRn () -> TcRn ()
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan (TcIdSigInfo -> SrcSpan
sig_loc TcIdSigInfo
orig_sig) (TcRn () -> TcRn ()) -> TcRn () -> TcRn ()
forall a b. (a -> b) -> a -> b
$
    SDoc -> TcRn ()
forall a. SDoc -> TcM a
failWith (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$
    SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "Overloaded signature conflicts with monomorphism restriction")
       2 (TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
orig_sig)
  | Bool
otherwise
  = () -> TcRn ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

{- Note [Partial type signatures and generalisation]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If /any/ of the signatures in the gropu is a partial type signature
   f :: _ -> Int
then we *always* use the InferGen plan, and hence tcPolyInfer.
We do this even for a local binding with -XMonoLocalBinds, when
we normally use NoGen.

Reasons:
  * The TcSigInfo for 'f' has a unification variable for the '_',
    whose TcLevel is one level deeper than the current level.
    (See pushTcLevelM in tcTySig.)  But NoGen doesn't increase
    the TcLevel like InferGen, so we lose the level invariant.

  * The signature might be   f :: forall a. _ -> a
    so it really is polymorphic.  It's not clear what it would
    mean to use NoGen on this, and indeed the ASSERT in tcLhs,
    in the (Just sig) case, checks that if there is a signature
    then we are using LetLclBndr, and hence a nested AbsBinds with
    increased TcLevel

It might be possible to fix these difficulties somehow, but there
doesn't seem much point.  Indeed, adding a partial type signature is a
way to get per-binding inferred generalisation.

We apply the MR if /all/ of the partial signatures lack a context.
In particular (Trac #11016):
   f2 :: (?loc :: Int) => _
   f2 = ?loc
It's stupid to apply the MR here.  This test includes an extra-constraints
wildcard; that is, we don't apply the MR if you write
   f3 :: _ => blah

Note [Quantified variables in partial type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
  f :: forall a. a -> a -> _
  f x y = g x y
  g :: forall b. b -> b -> _
  g x y = [x, y]

Here, 'f' and 'g' are mutually recursive, and we end up unifying 'a' and 'b'
together, which is fine.  So we bind 'a' and 'b' to TyVarTvs, which can then
unify with each other.

But now consider:
  f :: forall a b. a -> b -> _
  f x y = [x, y]

We want to get an error from this, because 'a' and 'b' get unified.
So we make a test, one per parital signature, to check that the
explicitly-quantified type variables have not been unified together.
Trac #14449 showed this up.


Note [Validity of inferred types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We need to check inferred type for validity, in case it uses language
extensions that are not turned on.  The principle is that if the user
simply adds the inferred type to the program source, it'll compile fine.
See #8883.

Examples that might fail:
 - the type might be ambiguous

 - an inferred theta that requires type equalities e.g. (F a ~ G b)
                                or multi-parameter type classes
 - an inferred type that includes unboxed tuples


Note [Impedance matching]
~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   f 0 x = x
   f n x = g [] (not x)

   g [] y = f 10 y
   g _  y = f 9  y

After typechecking we'll get
  f_mono_ty :: a -> Bool -> Bool
  g_mono_ty :: [b] -> Bool -> Bool
with constraints
  (Eq a, Num a)

Note that f is polymorphic in 'a' and g in 'b'; and these are not linked.
The types we really want for f and g are
   f :: forall a. (Eq a, Num a) => a -> Bool -> Bool
   g :: forall b. [b] -> Bool -> Bool

We can get these by "impedance matching":
   tuple :: forall a b. (Eq a, Num a) => (a -> Bool -> Bool, [b] -> Bool -> Bool)
   tuple a b d1 d1 = let ...bind f_mono, g_mono in (f_mono, g_mono)

   f a d1 d2 = case tuple a Any d1 d2 of (f, g) -> f
   g b = case tuple Integer b dEqInteger dNumInteger of (f,g) -> g

Suppose the shared quantified tyvars are qtvs and constraints theta.
Then we want to check that
     forall qtvs. theta => f_mono_ty   is more polymorphic than   f's polytype
and the proof is the impedance matcher.

Notice that the impedance matcher may do defaulting.  See Trac #7173.

It also cleverly does an ambiguity check; for example, rejecting
   f :: F a -> F a
where F is a non-injective type function.
-}


{-
Note [SPECIALISE pragmas]
~~~~~~~~~~~~~~~~~~~~~~~~~
There is no point in a SPECIALISE pragma for a non-overloaded function:
   reverse :: [a] -> [a]
   {-# SPECIALISE reverse :: [Int] -> [Int] #-}

But SPECIALISE INLINE *can* make sense for GADTS:
   data Arr e where
     ArrInt :: !Int -> ByteArray# -> Arr Int
     ArrPair :: !Int -> Arr e1 -> Arr e2 -> Arr (e1, e2)

   (!:) :: Arr e -> Int -> e
   {-# SPECIALISE INLINE (!:) :: Arr Int -> Int -> Int #-}
   {-# SPECIALISE INLINE (!:) :: Arr (a, b) -> Int -> (a, b) #-}
   (ArrInt _ ba)     !: (I# i) = I# (indexIntArray# ba i)
   (ArrPair _ a1 a2) !: i      = (a1 !: i, a2 !: i)

When (!:) is specialised it becomes non-recursive, and can usefully
be inlined.  Scary!  So we only warn for SPECIALISE *without* INLINE
for a non-overloaded function.

************************************************************************
*                                                                      *
                         tcMonoBinds
*                                                                      *
************************************************************************

@tcMonoBinds@ deals with a perhaps-recursive group of HsBinds.
The signatures have been dealt with already.
-}

data MonoBindInfo = MBI { MonoBindInfo -> Name
mbi_poly_name :: Name
                        , MonoBindInfo -> Maybe TcIdSigInst
mbi_sig       :: Maybe TcIdSigInst
                        , MonoBindInfo -> TyVar
mbi_mono_id   :: TcId }

tcMonoBinds :: RecFlag  -- Whether the binding is recursive for typechecking purposes
                        -- i.e. the binders are mentioned in their RHSs, and
                        --      we are not rescued by a type signature
            -> TcSigFun -> LetBndrSpec
            -> [LHsBind GhcRn]
            -> TcM (LHsBinds GhcTcId, [MonoBindInfo])
tcMonoBinds :: RecFlag
-> TcSigFun
-> LetBndrSpec
-> [LHsBindLR GhcRn GhcRn]
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
tcMonoBinds is_rec :: RecFlag
is_rec sig_fn :: TcSigFun
sig_fn no_gen :: LetBndrSpec
no_gen
           [ LHsBindLR GhcRn GhcRn
-> Located (SrcSpanLess (LHsBindLR GhcRn GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L b_loc :: SrcSpan
b_loc (FunBind { fun_id = (dL->L nm_loc name)
                                  , fun_matches = matches
                                  , fun_ext = fvs })]
                             -- Single function binding,
  | RecFlag
NonRecursive <- RecFlag
is_rec   -- ...binder isn't mentioned in RHS
  , Maybe TcSigInfo
Nothing <- TcSigFun
sig_fn Name
SrcSpanLess (Located Name)
name   -- ...with no type signature
  =     -- Note [Single function non-recursive binding special-case]
        -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        -- In this very special case we infer the type of the
        -- right hand side first (it may have a higher-rank type)
        -- and *then* make the monomorphic Id for the LHS
        -- e.g.         f = \(x::forall a. a->a) -> <body>
        --      We want to infer a higher-rank type for f
    SrcSpan
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
forall a. SrcSpan -> TcRn a -> TcRn a
setSrcSpan SrcSpan
b_loc    (TcM (LHsBinds GhcTc, [MonoBindInfo])
 -> TcM (LHsBinds GhcTc, [MonoBindInfo]))
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
forall a b. (a -> b) -> a -> b
$
    do  { ((co_fn :: HsWrapper
co_fn, matches' :: MatchGroup GhcTc (LHsExpr GhcTc)
matches'), rhs_ty :: Type
rhs_ty)
            <- (ExpRhoType -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM ((HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)), Type)
forall a. (ExpRhoType -> TcM a) -> TcM (a, Type)
tcInferInst ((ExpRhoType -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
 -> TcM ((HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)), Type))
-> (ExpRhoType
    -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM ((HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)), Type)
forall a b. (a -> b) -> a -> b
$ \ exp_ty :: ExpRhoType
exp_ty ->
                  -- tcInferInst: see TcUnify,
                  -- Note [Deep instantiation of InferResult]
               [TcBinder]
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a. [TcBinder] -> TcM a -> TcM a
tcExtendBinderStack [Name -> ExpRhoType -> TopLevelFlag -> TcBinder
TcIdBndr_ExpType Name
SrcSpanLess (Located Name)
name ExpRhoType
exp_ty TopLevelFlag
NotTopLevel] (TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
 -> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc)))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
forall a b. (a -> b) -> a -> b
$
                  -- We extend the error context even for a non-recursive
                  -- function so that in type error messages we show the
                  -- type of the thing whose rhs we are type checking
               Located Name
-> MatchGroup GhcRn (LHsExpr GhcRn)
-> ExpRhoType
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
tcMatchesFun (SrcSpan -> SrcSpanLess (Located Name) -> Located Name
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
nm_loc SrcSpanLess (Located Name)
name) MatchGroup GhcRn (LHsExpr GhcRn)
matches ExpRhoType
exp_ty

        ; TyVar
mono_id <- LetBndrSpec -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newLetBndr LetBndrSpec
no_gen Name
SrcSpanLess (Located Name)
name Type
rhs_ty
        ; (LHsBinds GhcTc, [MonoBindInfo])
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return (LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc
forall a. a -> Bag a
unitBag (LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc)
-> LHsBindLR GhcTc GhcTc -> LHsBinds GhcTc
forall a b. (a -> b) -> a -> b
$ SrcSpan
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
b_loc (SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc)
-> SrcSpanLess (LHsBindLR GhcTc GhcTc) -> LHsBindLR GhcTc GhcTc
forall a b. (a -> b) -> a -> b
$
                     FunBind :: forall idL idR.
XFunBind idL idR
-> Located (IdP idL)
-> MatchGroup idR (LHsExpr idR)
-> HsWrapper
-> [Tickish TyVar]
-> HsBindLR idL idR
FunBind { fun_id :: Located (IdP GhcTc)
fun_id = SrcSpan -> SrcSpanLess (Located TyVar) -> Located TyVar
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
nm_loc SrcSpanLess (Located TyVar)
TyVar
mono_id,
                               fun_matches :: MatchGroup GhcTc (LHsExpr GhcTc)
fun_matches = MatchGroup GhcTc (LHsExpr GhcTc)
matches', fun_ext :: XFunBind GhcTc GhcTc
fun_ext = XFunBind GhcRn GhcRn
XFunBind GhcTc GhcTc
fvs,
                               fun_co_fn :: HsWrapper
fun_co_fn = HsWrapper
co_fn, fun_tick :: [Tickish TyVar]
fun_tick = [] },
                  [MBI :: Name -> Maybe TcIdSigInst -> TyVar -> MonoBindInfo
MBI { mbi_poly_name :: Name
mbi_poly_name = Name
SrcSpanLess (Located Name)
name
                       , mbi_sig :: Maybe TcIdSigInst
mbi_sig       = Maybe TcIdSigInst
forall a. Maybe a
Nothing
                       , mbi_mono_id :: TyVar
mbi_mono_id   = TyVar
mono_id }]) }

tcMonoBinds _ sig_fn :: TcSigFun
sig_fn no_gen :: LetBndrSpec
no_gen binds :: [LHsBindLR GhcRn GhcRn]
binds
  = do  { [Located TcMonoBind]
tc_binds <- (LHsBindLR GhcRn GhcRn
 -> IOEnv (Env TcGblEnv TcLclEnv) (Located TcMonoBind))
-> [LHsBindLR GhcRn GhcRn]
-> IOEnv (Env TcGblEnv TcLclEnv) [Located TcMonoBind]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((SrcSpanLess (LHsBindLR GhcRn GhcRn)
 -> TcM (SrcSpanLess (Located TcMonoBind)))
-> LHsBindLR GhcRn GhcRn
-> IOEnv (Env TcGblEnv TcLclEnv) (Located TcMonoBind)
forall a b.
(HasSrcSpan a, HasSrcSpan b) =>
(SrcSpanLess a -> TcM (SrcSpanLess b)) -> a -> TcM b
wrapLocM (TcSigFun -> LetBndrSpec -> HsBindLR GhcRn GhcRn -> TcM TcMonoBind
tcLhs TcSigFun
sig_fn LetBndrSpec
no_gen)) [LHsBindLR GhcRn GhcRn]
binds

        -- Bring the monomorphic Ids, into scope for the RHSs
        ; let mono_infos :: [MonoBindInfo]
mono_infos = [Located TcMonoBind] -> [MonoBindInfo]
getMonoBindInfo [Located TcMonoBind]
tc_binds
              rhs_id_env :: [(Name, TyVar)]
rhs_id_env = [ (Name
name, TyVar
mono_id)
                           | MBI { mbi_poly_name :: MonoBindInfo -> Name
mbi_poly_name = Name
name
                                 , mbi_sig :: MonoBindInfo -> Maybe TcIdSigInst
mbi_sig       = Maybe TcIdSigInst
mb_sig
                                 , mbi_mono_id :: MonoBindInfo -> TyVar
mbi_mono_id   = TyVar
mono_id } <- [MonoBindInfo]
mono_infos
                           , case Maybe TcIdSigInst
mb_sig of
                               Just sig :: TcIdSigInst
sig -> TcIdSigInst -> Bool
isPartialSig TcIdSigInst
sig
                               Nothing  -> Bool
True ]
                -- A monomorphic binding for each term variable that lacks
                -- a complete type sig.  (Ones with a sig are already in scope.)

        ; String -> SDoc -> TcRn ()
traceTc "tcMonoBinds" (SDoc -> TcRn ()) -> SDoc -> TcRn ()
forall a b. (a -> b) -> a -> b
$ [SDoc] -> SDoc
vcat [ Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
n SDoc -> SDoc -> SDoc
<+> TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
id SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
idType TyVar
id)
                                       | (n :: Name
n,id :: TyVar
id) <- [(Name, TyVar)]
rhs_id_env]
        ; [LHsBindLR GhcTc GhcTc]
binds' <- [(Name, TyVar)]
-> TcM [LHsBindLR GhcTc GhcTc] -> TcM [LHsBindLR GhcTc GhcTc]
forall r. [(Name, TyVar)] -> TcM r -> TcM r
tcExtendRecIds [(Name, TyVar)]
rhs_id_env (TcM [LHsBindLR GhcTc GhcTc] -> TcM [LHsBindLR GhcTc GhcTc])
-> TcM [LHsBindLR GhcTc GhcTc] -> TcM [LHsBindLR GhcTc GhcTc]
forall a b. (a -> b) -> a -> b
$
                    (Located TcMonoBind
 -> IOEnv (Env TcGblEnv TcLclEnv) (LHsBindLR GhcTc GhcTc))
-> [Located TcMonoBind] -> TcM [LHsBindLR GhcTc GhcTc]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((SrcSpanLess (Located TcMonoBind)
 -> TcM (SrcSpanLess (LHsBindLR GhcTc GhcTc)))
-> Located TcMonoBind
-> IOEnv (Env TcGblEnv TcLclEnv) (LHsBindLR GhcTc GhcTc)
forall a b.
(HasSrcSpan a, HasSrcSpan b) =>
(SrcSpanLess a -> TcM (SrcSpanLess b)) -> a -> TcM b
wrapLocM SrcSpanLess (Located TcMonoBind)
-> TcM (SrcSpanLess (LHsBindLR GhcTc GhcTc))
TcMonoBind -> TcM (HsBindLR GhcTc GhcTc)
tcRhs) [Located TcMonoBind]
tc_binds

        ; (LHsBinds GhcTc, [MonoBindInfo])
-> TcM (LHsBinds GhcTc, [MonoBindInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return ([LHsBindLR GhcTc GhcTc] -> LHsBinds GhcTc
forall a. [a] -> Bag a
listToBag [LHsBindLR GhcTc GhcTc]
binds', [MonoBindInfo]
mono_infos) }


------------------------
-- tcLhs typechecks the LHS of the bindings, to construct the environment in which
-- we typecheck the RHSs.  Basically what we are doing is this: for each binder:
--      if there's a signature for it, use the instantiated signature type
--      otherwise invent a type variable
-- You see that quite directly in the FunBind case.
--
-- But there's a complication for pattern bindings:
--      data T = MkT (forall a. a->a)
--      MkT f = e
-- Here we can guess a type variable for the entire LHS (which will be refined to T)
-- but we want to get (f::forall a. a->a) as the RHS environment.
-- The simplest way to do this is to typecheck the pattern, and then look up the
-- bound mono-ids.  Then we want to retain the typechecked pattern to avoid re-doing
-- it; hence the TcMonoBind data type in which the LHS is done but the RHS isn't

data TcMonoBind         -- Half completed; LHS done, RHS not done
  = TcFunBind  MonoBindInfo  SrcSpan (MatchGroup GhcRn (LHsExpr GhcRn))
  | TcPatBind [MonoBindInfo] (LPat GhcTcId) (GRHSs GhcRn (LHsExpr GhcRn))
              TcSigmaType

tcLhs :: TcSigFun -> LetBndrSpec -> HsBind GhcRn -> TcM TcMonoBind
-- Only called with plan InferGen (LetBndrSpec = LetLclBndr)
--                    or NoGen    (LetBndrSpec = LetGblBndr)
-- CheckGen is used only for functions with a complete type signature,
--          and tcPolyCheck doesn't use tcMonoBinds at all

tcLhs :: TcSigFun -> LetBndrSpec -> HsBindLR GhcRn GhcRn -> TcM TcMonoBind
tcLhs sig_fn :: TcSigFun
sig_fn no_gen :: LetBndrSpec
no_gen (FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = (Located (IdP GhcRn) -> Located (SrcSpanLess (Located Name))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L nm_loc :: SrcSpan
nm_loc name :: SrcSpanLess (Located Name)
name)
                             , fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
matches })
  | Just (TcIdSig sig :: TcIdSigInfo
sig) <- TcSigFun
sig_fn Name
SrcSpanLess (Located Name)
name
  = -- There is a type signature.
    -- It must be partial; if complete we'd be in tcPolyCheck!
    --    e.g.   f :: _ -> _
    --           f x = ...g...
    --           Just g = ...f...
    -- Hence always typechecked with InferGen
    do { MonoBindInfo
mono_info <- LetBndrSpec -> (Name, TcIdSigInfo) -> TcM MonoBindInfo
tcLhsSigId LetBndrSpec
no_gen (Name
SrcSpanLess (Located Name)
name, TcIdSigInfo
sig)
       ; TcMonoBind -> TcM TcMonoBind
forall (m :: * -> *) a. Monad m => a -> m a
return (MonoBindInfo
-> SrcSpan -> MatchGroup GhcRn (LHsExpr GhcRn) -> TcMonoBind
TcFunBind MonoBindInfo
mono_info SrcSpan
nm_loc MatchGroup GhcRn (LHsExpr GhcRn)
matches) }

  | Bool
otherwise  -- No type signature
  = do { Type
mono_ty <- TcM Type
newOpenFlexiTyVarTy
       ; TyVar
mono_id <- LetBndrSpec -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newLetBndr LetBndrSpec
no_gen Name
SrcSpanLess (Located Name)
name Type
mono_ty
       ; let mono_info :: MonoBindInfo
mono_info = MBI :: Name -> Maybe TcIdSigInst -> TyVar -> MonoBindInfo
MBI { mbi_poly_name :: Name
mbi_poly_name = Name
SrcSpanLess (Located Name)
name
                             , mbi_sig :: Maybe TcIdSigInst
mbi_sig       = Maybe TcIdSigInst
forall a. Maybe a
Nothing
                             , mbi_mono_id :: TyVar
mbi_mono_id   = TyVar
mono_id }
       ; TcMonoBind -> TcM TcMonoBind
forall (m :: * -> *) a. Monad m => a -> m a
return (MonoBindInfo
-> SrcSpan -> MatchGroup GhcRn (LHsExpr GhcRn) -> TcMonoBind
TcFunBind MonoBindInfo
mono_info SrcSpan
nm_loc MatchGroup GhcRn (LHsExpr GhcRn)
matches) }

tcLhs sig_fn :: TcSigFun
sig_fn no_gen :: LetBndrSpec
no_gen (PatBind { pat_lhs :: forall idL idR. HsBindLR idL idR -> LPat idL
pat_lhs = LPat GhcRn
pat, pat_rhs :: forall idL idR. HsBindLR idL idR -> GRHSs idR (LHsExpr idR)
pat_rhs = GRHSs GhcRn (LHsExpr GhcRn)
grhss })
  = -- See Note [Typechecking pattern bindings]
    do  { [MonoBindInfo]
sig_mbis <- ((Name, TcIdSigInfo) -> TcM MonoBindInfo)
-> [(Name, TcIdSigInfo)]
-> IOEnv (Env TcGblEnv TcLclEnv) [MonoBindInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (LetBndrSpec -> (Name, TcIdSigInfo) -> TcM MonoBindInfo
tcLhsSigId LetBndrSpec
no_gen) [(Name, TcIdSigInfo)]
sig_names

        ; let inst_sig_fun :: Name -> Maybe TyVar
inst_sig_fun = NameEnv TyVar -> Name -> Maybe TyVar
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv (NameEnv TyVar -> Name -> Maybe TyVar)
-> NameEnv TyVar -> Name -> Maybe TyVar
forall a b. (a -> b) -> a -> b
$ [(Name, TyVar)] -> NameEnv TyVar
forall a. [(Name, a)] -> NameEnv a
mkNameEnv ([(Name, TyVar)] -> NameEnv TyVar)
-> [(Name, TyVar)] -> NameEnv TyVar
forall a b. (a -> b) -> a -> b
$
                             [ (MonoBindInfo -> Name
mbi_poly_name MonoBindInfo
mbi, MonoBindInfo -> TyVar
mbi_mono_id MonoBindInfo
mbi)
                             | MonoBindInfo
mbi <- [MonoBindInfo]
sig_mbis ]

            -- See Note [Existentials in pattern bindings]
        ; ((pat' :: LPat GhcTc
pat', nosig_mbis :: [MonoBindInfo]
nosig_mbis), pat_ty :: Type
pat_ty)
            <- SDoc
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (LPat GhcRn -> GRHSs GhcRn (LHsExpr GhcRn) -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
LPat (GhcPass p) -> GRHSs GhcRn body -> SDoc
patMonoBindsCtxt LPat GhcRn
pat GRHSs GhcRn (LHsExpr GhcRn)
grhss) (TcM ((LPat GhcTc, [MonoBindInfo]), Type)
 -> TcM ((LPat GhcTc, [MonoBindInfo]), Type))
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
forall a b. (a -> b) -> a -> b
$
               (ExpRhoType -> TcM (LPat GhcTc, [MonoBindInfo]))
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
forall a. (ExpRhoType -> TcM a) -> TcM (a, Type)
tcInferNoInst ((ExpRhoType -> TcM (LPat GhcTc, [MonoBindInfo]))
 -> TcM ((LPat GhcTc, [MonoBindInfo]), Type))
-> (ExpRhoType -> TcM (LPat GhcTc, [MonoBindInfo]))
-> TcM ((LPat GhcTc, [MonoBindInfo]), Type)
forall a b. (a -> b) -> a -> b
$ \ exp_ty :: ExpRhoType
exp_ty ->
               (Name -> Maybe TyVar)
-> LetBndrSpec
-> LPat GhcRn
-> ExpRhoType
-> IOEnv (Env TcGblEnv TcLclEnv) [MonoBindInfo]
-> TcM (LPat GhcTc, [MonoBindInfo])
forall a.
(Name -> Maybe TyVar)
-> LetBndrSpec
-> LPat GhcRn
-> ExpRhoType
-> TcM a
-> TcM (LPat GhcTc, a)
tcLetPat Name -> Maybe TyVar
inst_sig_fun LetBndrSpec
no_gen LPat GhcRn
pat ExpRhoType
exp_ty (IOEnv (Env TcGblEnv TcLclEnv) [MonoBindInfo]
 -> TcM (LPat GhcTc, [MonoBindInfo]))
-> IOEnv (Env TcGblEnv TcLclEnv) [MonoBindInfo]
-> TcM (LPat GhcTc, [MonoBindInfo])
forall a b. (a -> b) -> a -> b
$
               (Name -> TcM MonoBindInfo)
-> [Name] -> IOEnv (Env TcGblEnv TcLclEnv) [MonoBindInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Name -> TcM MonoBindInfo
lookup_info [Name]
nosig_names

        ; let mbis :: [MonoBindInfo]
mbis = [MonoBindInfo]
sig_mbis [MonoBindInfo] -> [MonoBindInfo] -> [MonoBindInfo]
forall a. [a] -> [a] -> [a]
++ [MonoBindInfo]
nosig_mbis

        ; String -> SDoc -> TcRn ()
traceTc "tcLhs" ([SDoc] -> SDoc
vcat [ TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
id SDoc -> SDoc -> SDoc
<+> SDoc
dcolon SDoc -> SDoc -> SDoc
<+> Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
idType TyVar
id)
                                | MonoBindInfo
mbi <- [MonoBindInfo]
mbis, let id :: TyVar
id = MonoBindInfo -> TyVar
mbi_mono_id MonoBindInfo
mbi ]
                           SDoc -> SDoc -> SDoc
$$ LetBndrSpec -> SDoc
forall a. Outputable a => a -> SDoc
ppr LetBndrSpec
no_gen)

        ; TcMonoBind -> TcM TcMonoBind
forall (m :: * -> *) a. Monad m => a -> m a
return ([MonoBindInfo]
-> LPat GhcTc -> GRHSs GhcRn (LHsExpr GhcRn) -> Type -> TcMonoBind
TcPatBind [MonoBindInfo]
mbis LPat GhcTc
pat' GRHSs GhcRn (LHsExpr GhcRn)
grhss Type
pat_ty) }
  where
    bndr_names :: [IdP GhcRn]
bndr_names = LPat GhcRn -> [IdP GhcRn]
forall (p :: Pass). LPat (GhcPass p) -> [IdP (GhcPass p)]
collectPatBinders LPat GhcRn
pat
    (nosig_names :: [Name]
nosig_names, sig_names :: [(Name, TcIdSigInfo)]
sig_names) = (Name -> Either Name (Name, TcIdSigInfo))
-> [Name] -> ([Name], [(Name, TcIdSigInfo)])
forall a b c. (a -> Either b c) -> [a] -> ([b], [c])
partitionWith Name -> Either Name (Name, TcIdSigInfo)
find_sig [Name]
[IdP GhcRn]
bndr_names

    find_sig :: Name -> Either Name (Name, TcIdSigInfo)
    find_sig :: Name -> Either Name (Name, TcIdSigInfo)
find_sig name :: Name
name = case TcSigFun
sig_fn Name
name of
                      Just (TcIdSig sig :: TcIdSigInfo
sig) -> (Name, TcIdSigInfo) -> Either Name (Name, TcIdSigInfo)
forall a b. b -> Either a b
Right (Name
name, TcIdSigInfo
sig)
                      _                  -> Name -> Either Name (Name, TcIdSigInfo)
forall a b. a -> Either a b
Left Name
name

      -- After typechecking the pattern, look up the binder
      -- names that lack a signature, which the pattern has brought
      -- into scope.
    lookup_info :: Name -> TcM MonoBindInfo
    lookup_info :: Name -> TcM MonoBindInfo
lookup_info name :: Name
name
      = do { TyVar
mono_id <- Name -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
tcLookupId Name
name
           ; MonoBindInfo -> TcM MonoBindInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (MBI :: Name -> Maybe TcIdSigInst -> TyVar -> MonoBindInfo
MBI { mbi_poly_name :: Name
mbi_poly_name = Name
name
                         , mbi_sig :: Maybe TcIdSigInst
mbi_sig       = Maybe TcIdSigInst
forall a. Maybe a
Nothing
                         , mbi_mono_id :: TyVar
mbi_mono_id   = TyVar
mono_id }) }

tcLhs _ _ other_bind :: HsBindLR GhcRn GhcRn
other_bind = String -> SDoc -> TcM TcMonoBind
forall a. HasCallStack => String -> SDoc -> a
pprPanic "tcLhs" (HsBindLR GhcRn GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBindLR GhcRn GhcRn
other_bind)
        -- AbsBind, VarBind impossible

-------------------
tcLhsSigId :: LetBndrSpec -> (Name, TcIdSigInfo) -> TcM MonoBindInfo
tcLhsSigId :: LetBndrSpec -> (Name, TcIdSigInfo) -> TcM MonoBindInfo
tcLhsSigId no_gen :: LetBndrSpec
no_gen (name :: Name
name, sig :: TcIdSigInfo
sig)
  = do { TcIdSigInst
inst_sig <- TcIdSigInfo -> TcM TcIdSigInst
tcInstSig TcIdSigInfo
sig
       ; TyVar
mono_id <- LetBndrSpec
-> Name -> TcIdSigInst -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newSigLetBndr LetBndrSpec
no_gen Name
name TcIdSigInst
inst_sig
       ; MonoBindInfo -> TcM MonoBindInfo
forall (m :: * -> *) a. Monad m => a -> m a
return (MBI :: Name -> Maybe TcIdSigInst -> TyVar -> MonoBindInfo
MBI { mbi_poly_name :: Name
mbi_poly_name = Name
name
                     , mbi_sig :: Maybe TcIdSigInst
mbi_sig       = TcIdSigInst -> Maybe TcIdSigInst
forall a. a -> Maybe a
Just TcIdSigInst
inst_sig
                     , mbi_mono_id :: TyVar
mbi_mono_id   = TyVar
mono_id }) }

------------
newSigLetBndr :: LetBndrSpec -> Name -> TcIdSigInst -> TcM TcId
newSigLetBndr :: LetBndrSpec
-> Name -> TcIdSigInst -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newSigLetBndr (LetGblBndr prags :: TcPragEnv
prags) name :: Name
name (TISI { sig_inst_sig :: TcIdSigInst -> TcIdSigInfo
sig_inst_sig = TcIdSigInfo
id_sig })
  | CompleteSig { sig_bndr :: TcIdSigInfo -> TyVar
sig_bndr = TyVar
poly_id } <- TcIdSigInfo
id_sig
  = TyVar -> [LSig GhcRn] -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
addInlinePrags TyVar
poly_id (TcPragEnv -> Name -> [LSig GhcRn]
lookupPragEnv TcPragEnv
prags Name
name)
newSigLetBndr no_gen :: LetBndrSpec
no_gen name :: Name
name (TISI { sig_inst_tau :: TcIdSigInst -> Type
sig_inst_tau = Type
tau })
  = LetBndrSpec -> Name -> Type -> IOEnv (Env TcGblEnv TcLclEnv) TyVar
newLetBndr LetBndrSpec
no_gen Name
name Type
tau

-------------------
tcRhs :: TcMonoBind -> TcM (HsBind GhcTcId)
tcRhs :: TcMonoBind -> TcM (HsBindLR GhcTc GhcTc)
tcRhs (TcFunBind info :: MonoBindInfo
info@(MBI { mbi_sig :: MonoBindInfo -> Maybe TcIdSigInst
mbi_sig = Maybe TcIdSigInst
mb_sig, mbi_mono_id :: MonoBindInfo -> TyVar
mbi_mono_id = TyVar
mono_id })
                 loc :: SrcSpan
loc matches :: MatchGroup GhcRn (LHsExpr GhcRn)
matches)
  = [MonoBindInfo]
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a. [MonoBindInfo] -> TcM a -> TcM a
tcExtendIdBinderStackForRhs [MonoBindInfo
info]  (TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc))
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a b. (a -> b) -> a -> b
$
    Maybe TcIdSigInst
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a. Maybe TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvForRhs Maybe TcIdSigInst
mb_sig       (TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc))
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a b. (a -> b) -> a -> b
$
    do  { String -> SDoc -> TcRn ()
traceTc "tcRhs: fun bind" (TyVar -> SDoc
forall a. Outputable a => a -> SDoc
ppr TyVar
mono_id SDoc -> SDoc -> SDoc
$$ Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr (TyVar -> Type
idType TyVar
mono_id))
        ; (co_fn :: HsWrapper
co_fn, matches' :: MatchGroup GhcTc (LHsExpr GhcTc)
matches') <- Located Name
-> MatchGroup GhcRn (LHsExpr GhcRn)
-> ExpRhoType
-> TcM (HsWrapper, MatchGroup GhcTc (LHsExpr GhcTc))
tcMatchesFun (SrcSpan -> SrcSpanLess (Located Name) -> Located Name
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc (TyVar -> Name
idName TyVar
mono_id))
                                 MatchGroup GhcRn (LHsExpr GhcRn)
matches (Type -> ExpRhoType
mkCheckExpType (Type -> ExpRhoType) -> Type -> ExpRhoType
forall a b. (a -> b) -> a -> b
$ TyVar -> Type
idType TyVar
mono_id)
        ; HsBindLR GhcTc GhcTc -> TcM (HsBindLR GhcTc GhcTc)
forall (m :: * -> *) a. Monad m => a -> m a
return ( FunBind :: forall idL idR.
XFunBind idL idR
-> Located (IdP idL)
-> MatchGroup idR (LHsExpr idR)
-> HsWrapper
-> [Tickish TyVar]
-> HsBindLR idL idR
FunBind { fun_id :: Located (IdP GhcTc)
fun_id = SrcSpan -> SrcSpanLess (Located TyVar) -> Located TyVar
forall a. HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a
cL SrcSpan
loc SrcSpanLess (Located TyVar)
TyVar
mono_id
                           , fun_matches :: MatchGroup GhcTc (LHsExpr GhcTc)
fun_matches = MatchGroup GhcTc (LHsExpr GhcTc)
matches'
                           , fun_co_fn :: HsWrapper
fun_co_fn = HsWrapper
co_fn
                           , fun_ext :: XFunBind GhcTc GhcTc
fun_ext = UniqSet Name
XFunBind GhcTc GhcTc
placeHolderNamesTc
                           , fun_tick :: [Tickish TyVar]
fun_tick = [] } ) }

tcRhs (TcPatBind infos :: [MonoBindInfo]
infos pat' :: LPat GhcTc
pat' grhss :: GRHSs GhcRn (LHsExpr GhcRn)
grhss pat_ty :: Type
pat_ty)
  = -- When we are doing pattern bindings we *don't* bring any scoped
    -- type variables into scope unlike function bindings
    -- Wny not?  They are not completely rigid.
    -- That's why we have the special case for a single FunBind in tcMonoBinds
    [MonoBindInfo]
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a. [MonoBindInfo] -> TcM a -> TcM a
tcExtendIdBinderStackForRhs [MonoBindInfo]
infos        (TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc))
-> TcM (HsBindLR GhcTc GhcTc) -> TcM (HsBindLR GhcTc GhcTc)
forall a b. (a -> b) -> a -> b
$
    do  { String -> SDoc -> TcRn ()
traceTc "tcRhs: pat bind" (LPat GhcTc -> SDoc
forall a. Outputable a => a -> SDoc
ppr LPat GhcTc
pat' SDoc -> SDoc -> SDoc
$$ Type -> SDoc
forall a. Outputable a => a -> SDoc
ppr Type
pat_ty)
        ; GRHSs GhcTc (LHsExpr GhcTc)
grhss' <- SDoc
-> TcM (GRHSs GhcTc (LHsExpr GhcTc))
-> TcM (GRHSs GhcTc (LHsExpr GhcTc))
forall a. SDoc -> TcM a -> TcM a
addErrCtxt (LPat GhcTc -> GRHSs GhcRn (LHsExpr GhcRn) -> SDoc
forall (p :: Pass) body.
(OutputableBndrId (GhcPass p), Outputable body) =>
LPat (GhcPass p) -> GRHSs GhcRn body -> SDoc
patMonoBindsCtxt LPat GhcTc
pat' GRHSs GhcRn (LHsExpr GhcRn)
grhss) (TcM (GRHSs GhcTc (LHsExpr GhcTc))
 -> TcM (GRHSs GhcTc (LHsExpr GhcTc)))
-> TcM (GRHSs GhcTc (LHsExpr GhcTc))
-> TcM (GRHSs GhcTc (LHsExpr GhcTc))
forall a b. (a -> b) -> a -> b
$
                    GRHSs GhcRn (LHsExpr GhcRn)
-> Type -> TcM (GRHSs GhcTc (LHsExpr GhcTc))
tcGRHSsPat GRHSs GhcRn (LHsExpr GhcRn)
grhss Type
pat_ty
        ; HsBindLR GhcTc GhcTc -> TcM (HsBindLR GhcTc GhcTc)
forall (m :: * -> *) a. Monad m => a -> m a
return ( PatBind :: forall idL idR.
XPatBind idL idR
-> LPat idL
-> GRHSs idR (LHsExpr idR)
-> ([Tickish TyVar], [[Tickish TyVar]])
-> HsBindLR idL idR
PatBind { pat_lhs :: LPat GhcTc
pat_lhs = LPat GhcTc
pat', pat_rhs :: GRHSs GhcTc (LHsExpr GhcTc)
pat_rhs = GRHSs GhcTc (LHsExpr GhcTc)
grhss'
                           , pat_ext :: XPatBind GhcTc GhcTc
pat_ext = UniqSet Name -> Type -> NPatBindTc
NPatBindTc UniqSet Name
placeHolderNamesTc Type
pat_ty
                           , pat_ticks :: ([Tickish TyVar], [[Tickish TyVar]])
pat_ticks = ([],[]) } )}

tcExtendTyVarEnvForRhs :: Maybe TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvForRhs :: Maybe TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvForRhs Nothing thing_inside :: TcM a
thing_inside
  = TcM a
thing_inside
tcExtendTyVarEnvForRhs (Just sig :: TcIdSigInst
sig) thing_inside :: TcM a
thing_inside
  = TcIdSigInst -> TcM a -> TcM a
forall a. TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvFromSig TcIdSigInst
sig TcM a
thing_inside

tcExtendTyVarEnvFromSig :: TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvFromSig :: TcIdSigInst -> TcM a -> TcM a
tcExtendTyVarEnvFromSig sig_inst :: TcIdSigInst
sig_inst thing_inside :: TcM a
thing_inside
  | TISI { sig_inst_skols :: TcIdSigInst -> [(Name, TyVar)]
sig_inst_skols = [(Name, TyVar)]
skol_prs, sig_inst_wcs :: TcIdSigInst -> [(Name, TyVar)]
sig_inst_wcs = [(Name, TyVar)]
wcs } <- TcIdSigInst
sig_inst
  = [(Name, TyVar)] -> TcM a -> TcM a
forall r. [(Name, TyVar)] -> TcM r -> TcM r
tcExtendNameTyVarEnv [(Name, TyVar)]
wcs (TcM a -> TcM a) -> TcM a -> TcM a
forall a b. (a -> b) -> a -> b
$
    [(Name, TyVar)] -> TcM a -> TcM a
forall r. [(Name, TyVar)] -> TcM r -> TcM r
tcExtendNameTyVarEnv [(Name, TyVar)]
skol_prs (TcM a -> TcM a) -> TcM a -> TcM a
forall a b. (a -> b) -> a -> b
$
    TcM a
thing_inside

tcExtendIdBinderStackForRhs :: [MonoBindInfo] -> TcM a -> TcM a
-- Extend the TcBinderStack for the RHS of the binding, with
-- the monomorphic Id.  That way, if we have, say
--     f = \x -> blah
-- and something goes wrong in 'blah', we get a "relevant binding"
-- looking like  f :: alpha -> beta
-- This applies if 'f' has a type signature too:
--    f :: forall a. [a] -> [a]
--    f x = True
-- We can't unify True with [a], and a relevant binding is f :: [a] -> [a]
-- If we had the *polymorphic* version of f in the TcBinderStack, it
-- would not be reported as relevant, because its type is closed
tcExtendIdBinderStackForRhs :: [MonoBindInfo] -> TcM a -> TcM a
tcExtendIdBinderStackForRhs infos :: [MonoBindInfo]
infos thing_inside :: TcM a
thing_inside
  = [TcBinder] -> TcM a -> TcM a
forall a. [TcBinder] -> TcM a -> TcM a
tcExtendBinderStack [ TyVar -> TopLevelFlag -> TcBinder
TcIdBndr TyVar
mono_id TopLevelFlag
NotTopLevel
                        | MBI { mbi_mono_id :: MonoBindInfo -> TyVar
mbi_mono_id = TyVar
mono_id } <- [MonoBindInfo]
infos ]
                        TcM a
thing_inside
    -- NotTopLevel: it's a monomorphic binding

---------------------
getMonoBindInfo :: [Located TcMonoBind] -> [MonoBindInfo]
getMonoBindInfo :: [Located TcMonoBind] -> [MonoBindInfo]
getMonoBindInfo tc_binds :: [Located TcMonoBind]
tc_binds
  = (Located TcMonoBind -> [MonoBindInfo] -> [MonoBindInfo])
-> [MonoBindInfo] -> [Located TcMonoBind] -> [MonoBindInfo]
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (TcMonoBind -> [MonoBindInfo] -> [MonoBindInfo]
get_info (TcMonoBind -> [MonoBindInfo] -> [MonoBindInfo])
-> (Located TcMonoBind -> TcMonoBind)
-> Located TcMonoBind
-> [MonoBindInfo]
-> [MonoBindInfo]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located TcMonoBind -> TcMonoBind
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) [] [Located TcMonoBind]
tc_binds
  where
    get_info :: TcMonoBind -> [MonoBindInfo] -> [MonoBindInfo]
get_info (TcFunBind info :: MonoBindInfo
info _ _)    rest :: [MonoBindInfo]
rest = MonoBindInfo
info MonoBindInfo -> [MonoBindInfo] -> [MonoBindInfo]
forall a. a -> [a] -> [a]
: [MonoBindInfo]
rest
    get_info (TcPatBind infos :: [MonoBindInfo]
infos _ _ _) rest :: [MonoBindInfo]
rest = [MonoBindInfo]
infos [MonoBindInfo] -> [MonoBindInfo] -> [MonoBindInfo]
forall a. [a] -> [a] -> [a]
++ [MonoBindInfo]
rest


{- Note [Typechecking pattern bindings]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Look at:
   - typecheck/should_compile/ExPat
   - Trac #12427, typecheck/should_compile/T12427{a,b}

  data T where
    MkT :: Integral a => a -> Int -> T

and suppose t :: T.  Which of these pattern bindings are ok?

  E1. let { MkT p _ = t } in <body>

  E2. let { MkT _ q = t } in <body>

  E3. let { MkT (toInteger -> r) _ = t } in <body>

* (E1) is clearly wrong because the existential 'a' escapes.
  What type could 'p' possibly have?

* (E2) is fine, despite the existential pattern, because
  q::Int, and nothing escapes.

* Even (E3) is fine.  The existential pattern binds a dictionary
  for (Integral a) which the view pattern can use to convert the
  a-valued field to an Integer, so r :: Integer.

An easy way to see all three is to imagine the desugaring.
For (E2) it would look like
    let q = case t of MkT _ q' -> q'
    in <body>


We typecheck pattern bindings as follows.  First tcLhs does this:

  1. Take each type signature q :: ty, partial or complete, and
     instantiate it (with tcLhsSigId) to get a MonoBindInfo.  This
     gives us a fresh "mono_id" qm :: instantiate(ty), where qm has
     a fresh name.

     Any fresh unification variables in instantiate(ty) born here, not
     deep under implications as would happen if we allocated them when
     we encountered q during tcPat.

  2. Build a little environment mapping "q" -> "qm" for those Ids
     with signatures (inst_sig_fun)

  3. Invoke tcLetPat to typecheck the pattern.

     - We pass in the current TcLevel.  This is captured by
       TcPat.tcLetPat, and put into the pc_lvl field of PatCtxt, in
       PatEnv.

     - When tcPat finds an existential constructor, it binds fresh
       type variables and dictionaries as usual, increments the TcLevel,
       and emits an implication constraint.

     - When we come to a binder (TcPat.tcPatBndr), it looks it up
       in the little environment (the pc_sig_fn field of PatCtxt).

         Success => There was a type signature, so just use it,
                    checking compatibility with the expected type.

         Failure => No type sigature.
             Infer case: (happens only outside any constructor pattern)
                         use a unification variable
                         at the outer level pc_lvl

             Check case: use promoteTcType to promote the type
                         to the outer level pc_lvl.  This is the
                         place where we emit a constraint that'll blow
                         up if existential capture takes place

       Result: the type of the binder is always at pc_lvl. This is
       crucial.

  4. Throughout, when we are making up an Id for the pattern-bound variables
     (newLetBndr), we have two cases:

     - If we are generalising (generalisation plan is InferGen or
       CheckGen), then the let_bndr_spec will be LetLclBndr.  In that case
       we want to bind a cloned, local version of the variable, with the
       type given by the pattern context, *not* by the signature (even if
       there is one; see Trac #7268). The mkExport part of the
       generalisation step will do the checking and impedance matching
       against the signature.

     - If for some some reason we are not generalising (plan = NoGen), the
       LetBndrSpec will be LetGblBndr.  In that case we must bind the
       global version of the Id, and do so with precisely the type given
       in the signature.  (Then we unify with the type from the pattern
       context type.)


And that's it!  The implication constraints check for the skolem
escape.  It's quite simple and neat, and more expressive than before
e.g. GHC 8.0 rejects (E2) and (E3).

Example for (E1), starting at level 1.  We generate
     p :: beta:1, with constraints (forall:3 a. Integral a => a ~ beta)
The (a~beta) can't float (because of the 'a'), nor be solved (because
beta is untouchable.)

Example for (E2), we generate
     q :: beta:1, with constraint (forall:3 a. Integral a => Int ~ beta)
The beta is untoucable, but floats out of the constraint and can
be solved absolutely fine.


************************************************************************
*                                                                      *
                Generalisation
*                                                                      *
********************************************************************* -}

data GeneralisationPlan
  = NoGen               -- No generalisation, no AbsBinds

  | InferGen            -- Implicit generalisation; there is an AbsBinds
       Bool             --   True <=> apply the MR; generalise only unconstrained type vars

  | CheckGen (LHsBind GhcRn) TcIdSigInfo
                        -- One FunBind with a signature
                        -- Explicit generalisation

-- A consequence of the no-AbsBinds choice (NoGen) is that there is
-- no "polymorphic Id" and "monmomorphic Id"; there is just the one

instance Outputable GeneralisationPlan where
  ppr :: GeneralisationPlan -> SDoc
ppr NoGen          = String -> SDoc
text "NoGen"
  ppr (InferGen b :: Bool
b)   = String -> SDoc
text "InferGen" SDoc -> SDoc -> SDoc
<+> Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
b
  ppr (CheckGen _ s :: TcIdSigInfo
s) = String -> SDoc
text "CheckGen" SDoc -> SDoc -> SDoc
<+> TcIdSigInfo -> SDoc
forall a. Outputable a => a -> SDoc
ppr TcIdSigInfo
s

decideGeneralisationPlan
   :: DynFlags -> [LHsBind GhcRn] -> IsGroupClosed -> TcSigFun
   -> GeneralisationPlan
decideGeneralisationPlan :: DynFlags
-> [LHsBindLR GhcRn GhcRn]
-> IsGroupClosed
-> TcSigFun
-> GeneralisationPlan
decideGeneralisationPlan dflags :: DynFlags
dflags lbinds :: [LHsBindLR GhcRn GhcRn]
lbinds closed :: IsGroupClosed
closed sig_fn :: TcSigFun
sig_fn
  | Bool
has_partial_sigs                         = Bool -> GeneralisationPlan
InferGen ([Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [Bool]
partial_sig_mrs)
  | Just (bind :: LHsBindLR GhcRn GhcRn
bind, sig :: TcIdSigInfo
sig) <- Maybe (LHsBindLR GhcRn GhcRn, TcIdSigInfo)
one_funbind_with_sig = LHsBindLR GhcRn GhcRn -> TcIdSigInfo -> GeneralisationPlan
CheckGen LHsBindLR GhcRn GhcRn
bind TcIdSigInfo
sig
  | IsGroupClosed -> Bool
do_not_generalise IsGroupClosed
closed                 = GeneralisationPlan
NoGen
  | Bool
otherwise                                = Bool -> GeneralisationPlan
InferGen Bool
mono_restriction
  where
    binds :: [HsBindLR GhcRn GhcRn]
binds = (LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn)
-> [LHsBindLR GhcRn GhcRn] -> [HsBindLR GhcRn GhcRn]
forall a b. (a -> b) -> [a] -> [b]
map LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc [LHsBindLR GhcRn GhcRn]
lbinds

    partial_sig_mrs :: [Bool]
    -- One for each partial signature (so empty => no partial sigs)
    -- The Bool is True if the signature has no constraint context
    --      so we should apply the MR
    -- See Note [Partial type signatures and generalisation]
    partial_sig_mrs :: [Bool]
partial_sig_mrs
      = [ [LHsType GhcRn] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [LHsType GhcRn]
SrcSpanLess (LHsContext GhcRn)
theta
        | TcIdSig (PartialSig { psig_hs_ty :: TcIdSigInfo -> LHsSigWcType GhcRn
psig_hs_ty = LHsSigWcType GhcRn
hs_ty })
            <- TcSigFun -> [Name] -> [TcSigInfo]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe TcSigFun
sig_fn ([LHsBindLR GhcRn GhcRn] -> [IdP GhcRn]
forall (p :: Pass) idR.
[LHsBindLR (GhcPass p) idR] -> [IdP (GhcPass p)]
collectHsBindListBinders [LHsBindLR GhcRn GhcRn]
lbinds)
        , let (_, LHsContext GhcRn -> Located (SrcSpanLess (LHsContext GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ theta :: SrcSpanLess (LHsContext GhcRn)
theta, _) = LHsType GhcRn
-> ([LHsTyVarBndr GhcRn], LHsContext GhcRn, LHsType GhcRn)
forall pass.
LHsType pass
-> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass)
splitLHsSigmaTy (LHsSigWcType GhcRn -> LHsType GhcRn
forall pass. LHsSigWcType pass -> LHsType pass
hsSigWcType LHsSigWcType GhcRn
hs_ty) ]

    has_partial_sigs :: Bool
has_partial_sigs   = Bool -> Bool
not ([Bool] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Bool]
partial_sig_mrs)

    mono_restriction :: Bool
mono_restriction  = Extension -> DynFlags -> Bool
xopt Extension
LangExt.MonomorphismRestriction DynFlags
dflags
                     Bool -> Bool -> Bool
&& (HsBindLR GhcRn GhcRn -> Bool) -> [HsBindLR GhcRn GhcRn] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any HsBindLR GhcRn GhcRn -> Bool
restricted [HsBindLR GhcRn GhcRn]
binds

    do_not_generalise :: IsGroupClosed -> Bool
do_not_generalise (IsGroupClosed _ True) = Bool
False
        -- The 'True' means that all of the group's
        -- free vars have ClosedTypeId=True; so we can ignore
        -- -XMonoLocalBinds, and generalise anyway
    do_not_generalise _ = Extension -> DynFlags -> Bool
xopt Extension
LangExt.MonoLocalBinds DynFlags
dflags

    -- With OutsideIn, all nested bindings are monomorphic
    -- except a single function binding with a signature
    one_funbind_with_sig :: Maybe (LHsBindLR GhcRn GhcRn, TcIdSigInfo)
one_funbind_with_sig
      | [lbind :: LHsBindLR GhcRn GhcRn
lbind@(LHsBindLR GhcRn GhcRn
-> Located (SrcSpanLess (LHsBindLR GhcRn GhcRn))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ (FunBind { fun_id = v }))] <- [LHsBindLR GhcRn GhcRn]
lbinds
      , Just (TcIdSig sig :: TcIdSigInfo
sig) <- TcSigFun
sig_fn (Located Name -> SrcSpanLess (Located Name)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located Name
Located (IdP GhcRn)
v)
      = (LHsBindLR GhcRn GhcRn, TcIdSigInfo)
-> Maybe (LHsBindLR GhcRn GhcRn, TcIdSigInfo)
forall a. a -> Maybe a
Just (LHsBindLR GhcRn GhcRn
lbind, TcIdSigInfo
sig)
      | Bool
otherwise
      = Maybe (LHsBindLR GhcRn GhcRn, TcIdSigInfo)
forall a. Maybe a
Nothing

    -- The Haskell 98 monomorphism restriction
    restricted :: HsBindLR GhcRn GhcRn -> Bool
restricted (PatBind {})                              = Bool
True
    restricted (VarBind { var_id :: forall idL idR. HsBindLR idL idR -> IdP idL
var_id = IdP GhcRn
v })                  = Name -> Bool
no_sig Name
IdP GhcRn
v
    restricted (FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = Located (IdP GhcRn)
v, fun_matches :: forall idL idR. HsBindLR idL idR -> MatchGroup idR (LHsExpr idR)
fun_matches = MatchGroup GhcRn (LHsExpr GhcRn)
m }) = MatchGroup GhcRn (LHsExpr GhcRn) -> Bool
forall id body. MatchGroup id body -> Bool
restricted_match MatchGroup GhcRn (LHsExpr GhcRn)
m
                                                           Bool -> Bool -> Bool
&& Name -> Bool
no_sig (Located Name -> SrcSpanLess (Located Name)
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc Located Name
Located (IdP GhcRn)
v)
    restricted b :: HsBindLR GhcRn GhcRn
b = String -> SDoc -> Bool
forall a. HasCallStack => String -> SDoc -> a
pprPanic "isRestrictedGroup/unrestricted" (HsBindLR GhcRn GhcRn -> SDoc
forall a. Outputable a => a -> SDoc
ppr HsBindLR GhcRn GhcRn
b)

    restricted_match :: MatchGroup id body -> Bool
restricted_match mg :: MatchGroup id body
mg = MatchGroup id body -> BKey
forall id body. MatchGroup id body -> BKey
matchGroupArity MatchGroup id body
mg BKey -> BKey -> Bool
forall a. Eq a => a -> a -> Bool
== 0
        -- No args => like a pattern binding
        -- Some args => a function binding

    no_sig :: Name -> Bool
no_sig n :: Name
n = Bool -> Bool
not (TcSigFun -> Name -> Bool
hasCompleteSig TcSigFun
sig_fn Name
n)

isClosedBndrGroup :: TcTypeEnv -> Bag (LHsBind GhcRn) -> IsGroupClosed
isClosedBndrGroup :: TcTypeEnv -> LHsBinds GhcRn -> IsGroupClosed
isClosedBndrGroup type_env :: TcTypeEnv
type_env binds :: LHsBinds GhcRn
binds
  = NameEnv (UniqSet Name) -> Bool -> IsGroupClosed
IsGroupClosed NameEnv (UniqSet Name)
fv_env Bool
type_closed
  where
    type_closed :: Bool
type_closed = (UniqSet Name -> Bool) -> NameEnv (UniqSet Name) -> Bool
forall elt. (elt -> Bool) -> UniqFM elt -> Bool
allUFM ((Name -> Bool) -> UniqSet Name -> Bool
nameSetAll Name -> Bool
is_closed_type_id) NameEnv (UniqSet Name)
fv_env

    fv_env :: NameEnv NameSet
    fv_env :: NameEnv (UniqSet Name)
fv_env = [(Name, UniqSet Name)] -> NameEnv (UniqSet Name)
forall a. [(Name, a)] -> NameEnv a
mkNameEnv ([(Name, UniqSet Name)] -> NameEnv (UniqSet Name))
-> [(Name, UniqSet Name)] -> NameEnv (UniqSet Name)
forall a b. (a -> b) -> a -> b
$ (LHsBindLR GhcRn GhcRn -> [(Name, UniqSet Name)])
-> LHsBinds GhcRn -> [(Name, UniqSet Name)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (HsBindLR GhcRn GhcRn -> [(Name, UniqSet Name)]
bindFvs (HsBindLR GhcRn GhcRn -> [(Name, UniqSet Name)])
-> (LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn)
-> LHsBindLR GhcRn GhcRn
-> [(Name, UniqSet Name)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LHsBindLR GhcRn GhcRn -> HsBindLR GhcRn GhcRn
forall a. HasSrcSpan a => a -> SrcSpanLess a
unLoc) LHsBinds GhcRn
binds

    bindFvs :: HsBindLR GhcRn GhcRn -> [(Name, NameSet)]
    bindFvs :: HsBindLR GhcRn GhcRn -> [(Name, UniqSet Name)]
bindFvs (FunBind { fun_id :: forall idL idR. HsBindLR idL idR -> Located (IdP idL)
fun_id = (Located (IdP GhcRn) -> Located (SrcSpanLess (Located Name))
forall a. HasSrcSpan a => a -> Located (SrcSpanLess a)
dL->L _ f :: SrcSpanLess (Located Name)
f)
                     , fun_ext :: forall idL idR. HsBindLR idL idR -> XFunBind idL idR
fun_ext = XFunBind GhcRn GhcRn
fvs })
       = let open_fvs :: UniqSet Name
open_fvs = UniqSet Name -> UniqSet Name
get_open_fvs UniqSet Name
XFunBind GhcRn GhcRn
fvs
         in [(Name
SrcSpanLess (Located Name)
f, UniqSet Name
open_fvs)]
    bindFvs (PatBind { pat_lhs :: forall idL idR. HsBindLR idL idR -> LPat idL
pat_lhs = LPat GhcRn
pat, pat_ext :: forall idL idR. HsBindLR idL idR -> XPatBind idL idR
pat_ext = XPatBind GhcRn GhcRn
fvs })
       = let open_fvs :: UniqSet Name
open_fvs = UniqSet Name -> UniqSet Name
get_open_fvs UniqSet Name
XPatBind GhcRn GhcRn
fvs
         in [(Name
b, UniqSet Name
open_fvs) | Name
b <- LPat GhcRn -> [IdP GhcRn]
forall (p :: Pass). LPat (GhcPass p) -> [IdP (GhcPass p)]
collectPatBinders LPat GhcRn
pat]
    bindFvs _
       = []

    get_open_fvs :: UniqSet Name -> UniqSet Name
get_open_fvs fvs :: UniqSet Name
fvs = (Name -> Bool) -> UniqSet Name -> UniqSet Name
filterNameSet (Bool -> Bool
not (Bool -> Bool) -> (Name -> Bool) -> Name -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Bool
is_closed) UniqSet Name
fvs

    is_closed :: Name -> ClosedTypeId
    is_closed :: Name -> Bool
is_closed name :: Name
name
      | Just thing :: TcTyThing
thing <- TcTypeEnv -> Name -> Maybe TcTyThing
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv TcTypeEnv
type_env Name
name
      = case TcTyThing
thing of
          AGlobal {}                     -> Bool
True
          ATcId { tct_info :: TcTyThing -> IdBindingInfo
tct_info = IdBindingInfo
ClosedLet } -> Bool
True
          _                              -> Bool
False

      | Bool
otherwise
      = Bool
True  -- The free-var set for a top level binding mentions


    is_closed_type_id :: Name -> Bool
    -- We're already removed Global and ClosedLet Ids
    is_closed_type_id :: Name -> Bool
is_closed_type_id name :: Name
name
      | Just thing :: TcTyThing
thing <- TcTypeEnv -> Name -> Maybe TcTyThing
forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv TcTypeEnv
type_env Name
name
      = case TcTyThing
thing of
          ATcId { tct_info :: TcTyThing -> IdBindingInfo
tct_info = NonClosedLet _ cl :: Bool
cl } -> Bool
cl
          ATcId { tct_info :: TcTyThing -> IdBindingInfo
tct_info = IdBindingInfo
NotLetBound }       -> Bool
False
          ATyVar {}                              -> Bool
False
               -- In-scope type variables are not closed!
          _ -> String -> SDoc -> Bool
forall a. HasCallStack => String -> SDoc -> a
pprPanic "is_closed_id" (Name -> SDoc
forall a. Outputable a => a -> SDoc
ppr Name
name)

      | Bool
otherwise
      = Bool
True   -- The free-var set for a top level binding mentions
               -- imported things too, so that we can report unused imports
               -- These won't be in the local type env.
               -- Ditto class method etc from the current module


{- *********************************************************************
*                                                                      *
               Error contexts and messages
*                                                                      *
********************************************************************* -}

-- This one is called on LHS, when pat and grhss are both Name
-- and on RHS, when pat is TcId and grhss is still Name
patMonoBindsCtxt :: (OutputableBndrId (GhcPass p), Outputable body)
                 => LPat (GhcPass p) -> GRHSs GhcRn body -> SDoc
patMonoBindsCtxt :: LPat (GhcPass p) -> GRHSs GhcRn body -> SDoc
patMonoBindsCtxt pat :: LPat (GhcPass p)
pat grhss :: GRHSs GhcRn body
grhss
  = SDoc -> BKey -> SDoc -> SDoc
hang (String -> SDoc
text "In a pattern binding:") 2 (LPat (GhcPass p) -> GRHSs GhcRn body -> SDoc
forall (bndr :: Pass) (p :: Pass) body.
(OutputableBndrId (GhcPass bndr), OutputableBndrId (GhcPass p),
 Outputable body) =>
LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc
pprPatBind LPat (GhcPass p)
pat GRHSs GhcRn body
grhss)