    {-# LANGUAGE NondecreasingIndentation #-}

    module Agda.TypeChecking.Rules.Application
      ( checkArguments
      , checkArguments_
      , checkApplication
      , inferApplication
      , checkProjAppToKnownPrincipalArg
      ) where

    import Prelude hiding ( null )

    import Control.Applicative        ( (<|>) )
    import Control.Monad              ( forM, forM_, guard, liftM2 )
    import Control.Monad.Except
    import Control.Monad.Trans
    import Control.Monad.Trans.Maybe
    import Control.Monad.Reader

    import Data.Bifunctor
    import Data.Maybe
    import Data.Void
    import qualified Data.Foldable as Fold
    import qualified Data.IntSet   as IntSet

    import Agda.Interaction.Highlighting.Generate
      ( storeDisambiguatedConstructor, storeDisambiguatedProjection )
    import Agda.Interaction.Options

    import qualified Agda.Syntax.Abstract as A
    import Agda.Syntax.Abstract.Views as A
    import qualified Agda.Syntax.Info as A
    import Agda.Syntax.Concrete.Pretty () -- only Pretty instances
    import Agda.Syntax.Common
    import Agda.Syntax.Internal as I
    import Agda.Syntax.Position

    import Agda.TypeChecking.Conversion
    import Agda.TypeChecking.Constraints
    import Agda.TypeChecking.Datatypes
    import Agda.TypeChecking.Free
    import Agda.TypeChecking.Free.Lazy (VarMap, lookupVarMap)
    import Agda.TypeChecking.Implicit
    import Agda.TypeChecking.Injectivity
    import Agda.TypeChecking.Irrelevance
    import Agda.TypeChecking.InstanceArguments (postponeInstanceConstraints)
    import Agda.TypeChecking.Level
    import Agda.TypeChecking.MetaVars
    import Agda.TypeChecking.Names
    import Agda.TypeChecking.Pretty
    import Agda.TypeChecking.Primitive
    import Agda.TypeChecking.Monad
    import Agda.TypeChecking.Records
    import Agda.TypeChecking.Reduce
    import Agda.TypeChecking.Rules.Def
    import Agda.TypeChecking.Rules.Term
    import Agda.TypeChecking.Substitute
    import Agda.TypeChecking.Telescope

    import Agda.Utils.Either
    import Agda.Utils.Functor
    import Agda.Utils.Lens
    import Agda.Utils.List  ( (!!!), groupOn, initWithDefault )
    import Agda.Utils.List1 ( List1, pattern (:|) )
    import qualified Agda.Utils.List1 as List1
    import Agda.Utils.Maybe
    import Agda.Utils.Monad
    import Agda.Utils.Null
    import Agda.Utils.Pretty ( prettyShow )
    import Agda.Utils.Size
    import Agda.Utils.Tuple

    import Agda.Utils.Impossible

    -----------------------------------------------------------------------------
    -- * Applications
    -----------------------------------------------------------------------------

    -- | Ranges of checked arguments, where present.
    type MaybeRanges = [Maybe Range]

    acHeadConstraints :: (Elims -> Term) -> ArgsCheckState a -> [Constraint]
    acHeadConstraints :: forall a. (Elims -> Term) -> ArgsCheckState a -> [Constraint]
    acHeadConstraints Elims -> Term
    hd ACState{acElims :: forall a. ArgsCheckState a -> Elims
    acElims = Elims
    es, acConstraints :: forall a. ArgsCheckState a -> [Maybe (Abs Constraint)]
    acConstraints = [Maybe (Abs Constraint)]
    cs} = (Elims -> SubstArg Constraint)
    -> Elims -> [Maybe (Abs Constraint)] -> [Constraint]
    forall {a} {a}.
    Subst a =>
    ([a] -> SubstArg a) -> [a] -> [Maybe (Abs a)] -> [a]
    go Elims -> Term
    Elims -> SubstArg Constraint
    hd Elims
    es [Maybe (Abs Constraint)]
    cs
      where
        go :: ([a] -> SubstArg a) -> [a] -> [Maybe (Abs a)] -> [a]
    go [a] -> SubstArg a
    hd [] [] = []
        go [a] -> SubstArg a
    hd (a
    e : [a]
    es) (Maybe (Abs a)
    c : [Maybe (Abs a)]
    cs) = ([a] -> [a])
    -> (Abs a -> [a] -> [a]) -> Maybe (Abs a) -> [a] -> [a]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [a] -> [a]
    forall a. a -> a
    id (\ Abs a
    c -> (Abs a -> SubstArg a -> a
    forall a. Subst a => Abs a -> SubstArg a -> a
    lazyAbsApp Abs a
    c ([a] -> SubstArg a
    hd []) a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :)) Maybe (Abs a)
    c ([a] -> [a]) -> [a] -> [a]
    forall a b. (a -> b) -> a -> b
    $ ([a] -> SubstArg a) -> [a] -> [Maybe (Abs a)] -> [a]
    go ([a] -> SubstArg a
    hd ([a] -> SubstArg a) -> ([a] -> [a]) -> [a] -> SubstArg a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a
    e a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :)) [a]
    es [Maybe (Abs a)]
    cs
        go [a] -> SubstArg a
    _  [] (Maybe (Abs a)
    _:[Maybe (Abs a)]
    _) = [a]
    forall a. HasCallStack => a
    __IMPOSSIBLE__
        go [a] -> SubstArg a
    _  (a
    _:[a]
    _) [] = [a]
    forall a. HasCallStack => a
    __IMPOSSIBLE__

    checkHeadConstraints :: (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints :: forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints Elims -> Term
    hd ArgsCheckState a
    st = do
      (Constraint -> TCMT IO ()) -> [Constraint] -> TCMT IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ Constraint -> TCMT IO ()
    solveConstraint_ ((Elims -> Term) -> ArgsCheckState a -> [Constraint]
    forall a. (Elims -> Term) -> ArgsCheckState a -> [Constraint]
    acHeadConstraints Elims -> Term
    hd ArgsCheckState a
    st)
      Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Elims -> Term
    hd (ArgsCheckState a -> Elims
    forall a. ArgsCheckState a -> Elims
    acElims ArgsCheckState a
    st)

    -- | @checkApplication hd args e t@ checks an application.
    --   Precondition: @Application hs args = appView e@
    --
    --   @checkApplication@ disambiguates constructors
    --   (and continues to 'checkConstructorApplication')
    --   and resolves pattern synonyms.
    checkApplication :: Comparison -> A.Expr -> A.Args -> A.Expr -> Type -> TCM Term
    checkApplication :: Comparison -> Expr -> [NamedArg Expr] -> Expr -> Type -> TCM Term
    checkApplication Comparison
    cmp Expr
    hd [NamedArg Expr]
    args Expr
    e Type
    t =
      Expr -> TCM Term -> TCM Term
    forall a. Expr -> TCM a -> TCM a
    turnOffExpandLastIfExistingMeta Expr
    hd (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $
      TCM Term -> TCM Term
    forall a. TCM a -> TCM a
    postponeInstanceConstraints (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.check.app" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
        [ TCMT IO Doc
    "checkApplication"
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "hd   = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA Expr
    hd
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "args = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep ((NamedArg Expr -> TCMT IO Doc) -> [NamedArg Expr] -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map NamedArg Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA [NamedArg Expr]
    args)
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "e    = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA Expr
    e
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "t    = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t
        ]
      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.check.app" Nat
    70 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
        [ TCMT IO Doc
    "checkApplication (raw)"
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "hd   = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Expr -> [Char]
    forall a. Show a => a -> [Char]
    show Expr
    hd
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "args = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [NamedArg Expr] -> [Char]
    forall a. Show a => a -> [Char]
    show ([NamedArg Expr] -> [NamedArg Expr]
    forall a. ExprLike a => a -> a
    deepUnscope [NamedArg Expr]
    args)
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "e    = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Expr -> [Char]
    forall a. Show a => a -> [Char]
    show (Expr -> Expr
    forall a. ExprLike a => a -> a
    deepUnscope Expr
    e)
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "t    = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Type -> [Char]
    forall a. Show a => a -> [Char]
    show Type
    t
        ]
      case Expr -> Expr
    unScope Expr
    hd of
        -- Subcase: unambiguous projection
        A.Proj ProjOrigin
    o AmbiguousQName
    p | Just QName
    x <- AmbiguousQName -> Maybe QName
    getUnambiguous AmbiguousQName
    p -> do
          Comparison
    -> Expr
    -> Type
    -> QName
    -> ProjOrigin
    -> Expr
    -> [NamedArg Expr]
    -> TCM Term
    checkUnambiguousProjectionApplication Comparison
    cmp Expr
    e Type
    t QName
    x ProjOrigin
    o Expr
    hd [NamedArg Expr]
    args

        -- Subcase: ambiguous projection
        A.Proj ProjOrigin
    o AmbiguousQName
    p -> do
          Comparison
    -> Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Type
    -> TCM Term
    checkProjApp Comparison
    cmp Expr
    e ProjOrigin
    o (AmbiguousQName -> List1 QName
    unAmbQ AmbiguousQName
    p) [NamedArg Expr]
    args Type
    t

        -- Subcase: unambiguous constructor
        A.Con AmbiguousQName
    ambC | Just QName
    c <- AmbiguousQName -> Maybe QName
    getUnambiguous AmbiguousQName
    ambC -> do
          -- augment c with record fields, but do not revert to original name
          ConHead
    con <- (SigError -> TCMT IO ConHead)
    -> TCMT IO (Either SigError ConHead) -> TCMT IO ConHead
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> m (Either a b) -> m b
    fromRightM (([Char] -> TCMT IO ConHead)
    -> TCMT IO ConHead -> SigError -> TCMT IO ConHead
    forall a. ([Char] -> a) -> a -> SigError -> a
    sigError [Char] -> TCMT IO ConHead
    forall (m :: * -> *) a.
    (HasCallStack, MonadDebug m) =>
    [Char] -> m a
    __IMPOSSIBLE_VERBOSE__ (TypeError -> TCMT IO ConHead
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ConHead) -> TypeError -> TCMT IO ConHead
    forall a b. (a -> b) -> a -> b
    $ QName -> TypeError
    AbstractConstructorNotInScope QName
    c)) (TCMT IO (Either SigError ConHead) -> TCMT IO ConHead)
    -> TCMT IO (Either SigError ConHead) -> TCMT IO ConHead
    forall a b. (a -> b) -> a -> b
    $
            QName -> TCMT IO (Either SigError ConHead)
    getOrigConHead QName
    c
          Comparison
    -> Expr -> Type -> ConHead -> [NamedArg Expr] -> TCM Term
    checkConstructorApplication Comparison
    cmp Expr
    e Type
    t ConHead
    con [NamedArg Expr]
    args

        -- Subcase: ambiguous constructor
        A.Con (AmbQ List1 QName
    cs0) -> List1 QName -> Type -> TCM (Either Blocker ConHead)
    disambiguateConstructor List1 QName
    cs0 Type
    t TCM (Either Blocker ConHead)
    -> (Either Blocker ConHead -> TCM Term) -> TCM Term
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \ case
          Left Blocker
    unblock -> TypeCheckingProblem -> Blocker -> TCM Term
    postponeTypeCheckingProblem (Comparison -> Expr -> Type -> TypeCheckingProblem
    CheckExpr Comparison
    cmp Expr
    e Type
    t) Blocker
    unblock
          Right ConHead
    c      -> Comparison
    -> Expr -> Type -> ConHead -> [NamedArg Expr] -> TCM Term
    checkConstructorApplication Comparison
    cmp Expr
    e Type
    t ConHead
    c [NamedArg Expr]
    args

        -- Subcase: pattern synonym
        A.PatternSyn AmbiguousQName
    n -> do
          ([Arg Name]
    ns, Pattern' Void
    p) <- AmbiguousQName -> TCM ([Arg Name], Pattern' Void)
    lookupPatternSyn AmbiguousQName
    n
          Pattern' Expr
    p <- Pattern' Expr -> TCMT IO (Pattern' Expr)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Pattern' Expr -> TCMT IO (Pattern' Expr))
    -> Pattern' Expr -> TCMT IO (Pattern' Expr)
    forall a b. (a -> b) -> a -> b
    $ Range -> Pattern' Expr -> Pattern' Expr
    forall a. SetRange a => Range -> a -> a
    setRange (AmbiguousQName -> Range
    forall a. HasRange a => a -> Range
    getRange AmbiguousQName
    n) (Pattern' Expr -> Pattern' Expr) -> Pattern' Expr -> Pattern' Expr
    forall a b. (a -> b) -> a -> b
    $ Pattern' Expr -> Pattern' Expr
    forall a. KillRange a => KillRangeT a
    killRange (Pattern' Expr -> Pattern' Expr) -> Pattern' Expr -> Pattern' Expr
    forall a b. (a -> b) -> a -> b
    $ Pattern' Void -> Pattern' Expr
    forall (f :: * -> *) a. Functor f => f Void -> f a
    vacuous Pattern' Void
    p   -- Pattern' Void -> Pattern' Expr
          -- Expand the pattern synonym by substituting for
          -- the arguments we have got and lambda-lifting
          -- over the ones we haven't.
          let meta :: Range -> Expr
    meta Range
    r = MetaInfo -> Expr
    A.Underscore (MetaInfo -> Expr) -> MetaInfo -> Expr
    forall a b. (a -> b) -> a -> b
    $ MetaInfo
    A.emptyMetaInfo{ metaRange :: Range
    A.metaRange = Range
    r }   -- TODO: name suggestion
          case (Range -> Expr)
    -> Range
    -> [Arg Name]
    -> [NamedArg Expr]
    -> Maybe ([(Name, Expr)], [Arg Name])
    forall a.
    HasRange a =>
    (Range -> a)
    -> Range
    -> [Arg Name]
    -> [NamedArg a]
    -> Maybe ([(Name, a)], [Arg Name])
    A.insertImplicitPatSynArgs Range -> Expr
    meta (AmbiguousQName -> Range
    forall a. HasRange a => a -> Range
    getRange AmbiguousQName
    n) [Arg Name]
    ns [NamedArg Expr]
    args of
            Maybe ([(Name, Expr)], [Arg Name])
    Nothing      -> TypeError -> TCM Term
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM Term) -> TypeError -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ AmbiguousQName -> TypeError
    BadArgumentsToPatternSynonym AmbiguousQName
    n
            Just ([(Name, Expr)]
    s, [Arg Name]
    ns) -> do
              let p' :: Expr
    p' = Pattern' Expr -> Expr
    A.patternToExpr Pattern' Expr
    p
                  e' :: Expr
    e' = [Name] -> Expr -> Expr
    A.lambdaLiftExpr ((Arg Name -> Name) -> [Arg Name] -> [Name]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Name -> Name
    forall e. Arg e -> e
    unArg [Arg Name]
    ns) ([(Name, Expr)] -> Expr -> Expr
    forall a. SubstExpr a => [(Name, Expr)] -> a -> a
    A.substExpr [(Name, Expr)]
    s Expr
    p')
              Comparison -> Expr -> Type -> TCM Term
    checkExpr' Comparison
    cmp Expr
    e' Type
    t

        -- Subcase: macro
        A.Macro QName
    x -> do
          -- First go: no parameters
          TelV Tele (Dom Type)
    tel Type
    _ <- Type -> TCMT IO (TelV Type)
    forall (m :: * -> *).
    (MonadReduce m, MonadAddContext m) =>
    Type -> m (TelV Type)
    telView (Type -> TCMT IO (TelV Type))
    -> (Definition -> Type) -> Definition -> TCMT IO (TelV Type)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Definition -> Type
    defType (Definition -> TCMT IO (TelV Type))
    -> TCMT IO Definition -> TCMT IO (TelV Type)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Definition -> TCMT IO Definition
    forall (m :: * -> *).
    (Functor m, HasConstInfo m, HasOptions m, ReadTCState m,
     MonadTCEnv m, MonadDebug m) =>
    Definition -> m Definition
    instantiateDef (Definition -> TCMT IO Definition)
    -> TCMT IO Definition -> TCMT IO Definition
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    x

          Term
    tTerm <- TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primAgdaTerm
          Term
    tName <- TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primQName

          -- Andreas, 2021-05-13, can we use @initWithDefault __IMPOSSIBLE__@ here?
          let argTel :: [Dom ([Char], Type)]
    argTel   = [Dom ([Char], Type)] -> [Dom ([Char], Type)]
    forall a. [a] -> [a]
    init ([Dom ([Char], Type)] -> [Dom ([Char], Type)])
    -> [Dom ([Char], Type)] -> [Dom ([Char], Type)]
    forall a b. (a -> b) -> a -> b
    $ Tele (Dom Type) -> [Dom ([Char], Type)]
    forall t. Tele (Dom t) -> [Dom ([Char], t)]
    telToList Tele (Dom Type)
    tel -- last argument is the hole term

              -- inspect macro type to figure out if arguments need to be wrapped in quote/quoteTerm
              mkArg :: Type -> NamedArg A.Expr -> NamedArg A.Expr
              mkArg :: Type -> NamedArg Expr -> NamedArg Expr
    mkArg Type
    t NamedArg Expr
    a | Type -> Term
    forall t a. Type'' t a -> a
    unEl Type
    t Term -> Term -> Bool
    forall a. Eq a => a -> a -> Bool
    == Term
    tTerm =
                ((Named_ Expr -> Named_ Expr) -> NamedArg Expr -> NamedArg Expr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Named_ Expr -> Named_ Expr) -> NamedArg Expr -> NamedArg Expr)
    -> ((Expr -> Expr) -> Named_ Expr -> Named_ Expr)
    -> (Expr -> Expr)
    -> NamedArg Expr
    -> NamedArg Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Expr -> Expr) -> Named_ Expr -> Named_ Expr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap)
                  (AppInfo -> Expr -> NamedArg Expr -> Expr
    A.App (Range -> AppInfo
    A.defaultAppInfo (NamedArg Expr -> Range
    forall a. HasRange a => a -> Range
    getRange NamedArg Expr
    a)) (ExprInfo -> Expr
    A.QuoteTerm ExprInfo
    A.exprNoRange) (NamedArg Expr -> Expr) -> (Expr -> NamedArg Expr) -> Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Expr -> NamedArg Expr
    forall a. a -> NamedArg a
    defaultNamedArg) NamedArg Expr
    a
              mkArg Type
    t NamedArg Expr
    a | Type -> Term
    forall t a. Type'' t a -> a
    unEl Type
    t Term -> Term -> Bool
    forall a. Eq a => a -> a -> Bool
    == Term
    tName =
                ((Named_ Expr -> Named_ Expr) -> NamedArg Expr -> NamedArg Expr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ((Named_ Expr -> Named_ Expr) -> NamedArg Expr -> NamedArg Expr)
    -> ((Expr -> Expr) -> Named_ Expr -> Named_ Expr)
    -> (Expr -> Expr)
    -> NamedArg Expr
    -> NamedArg Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Expr -> Expr) -> Named_ Expr -> Named_ Expr
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap)
                  (AppInfo -> Expr -> NamedArg Expr -> Expr
    A.App (Range -> AppInfo
    A.defaultAppInfo (NamedArg Expr -> Range
    forall a. HasRange a => a -> Range
    getRange NamedArg Expr
    a)) (ExprInfo -> Expr
    A.Quote ExprInfo
    A.exprNoRange) (NamedArg Expr -> Expr) -> (Expr -> NamedArg Expr) -> Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Expr -> NamedArg Expr
    forall a. a -> NamedArg a
    defaultNamedArg) NamedArg Expr
    a
              mkArg Type
    t NamedArg Expr
    a | Bool
    otherwise = NamedArg Expr
    a

              makeArgs :: [Dom (String, Type)] -> [NamedArg A.Expr] -> ([NamedArg A.Expr], [NamedArg A.Expr])
              makeArgs :: [Dom ([Char], Type)]
    -> [NamedArg Expr] -> ([NamedArg Expr], [NamedArg Expr])
    makeArgs [] [NamedArg Expr]
    args = ([], [NamedArg Expr]
    args)
              makeArgs [Dom ([Char], Type)]
    _  []   = ([], [])
              makeArgs tel :: [Dom ([Char], Type)]
    tel@(Dom ([Char], Type)
    d : [Dom ([Char], Type)]
    tel1) (NamedArg Expr
    arg : [NamedArg Expr]
    args) =
                case NamedArg Expr -> [Dom ([Char], Type)] -> ImplicitInsertion
    forall e a. NamedArg e -> [Dom a] -> ImplicitInsertion
    insertImplicit NamedArg Expr
    arg [Dom ([Char], Type)]
    tel of
                  ImplicitInsertion
    NoInsertNeeded -> ([NamedArg Expr] -> [NamedArg Expr])
    -> ([NamedArg Expr], [NamedArg Expr])
    -> ([NamedArg Expr], [NamedArg Expr])
    forall (p :: * -> * -> *) a b c.
    Bifunctor p =>
    (a -> b) -> p a c -> p b c
    first (Type -> NamedArg Expr -> NamedArg Expr
    mkArg (([Char], Type) -> Type
    forall a b. (a, b) -> b
    snd (([Char], Type) -> Type) -> ([Char], Type) -> Type
    forall a b. (a -> b) -> a -> b
    $ Dom ([Char], Type) -> ([Char], Type)
    forall t e. Dom' t e -> e
    unDom Dom ([Char], Type)
    d) NamedArg Expr
    arg NamedArg Expr -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. a -> [a] -> [a]
    :) (([NamedArg Expr], [NamedArg Expr])
     -> ([NamedArg Expr], [NamedArg Expr]))
    -> ([NamedArg Expr], [NamedArg Expr])
    -> ([NamedArg Expr], [NamedArg Expr])
    forall a b. (a -> b) -> a -> b
    $ [Dom ([Char], Type)]
    -> [NamedArg Expr] -> ([NamedArg Expr], [NamedArg Expr])
    makeArgs [Dom ([Char], Type)]
    tel1 [NamedArg Expr]
    args
                  ImpInsert [Dom ()]
    is   -> [Dom ([Char], Type)]
    -> [NamedArg Expr] -> ([NamedArg Expr], [NamedArg Expr])
    makeArgs (Nat -> [Dom ([Char], Type)] -> [Dom ([Char], Type)]
    forall a. Nat -> [a] -> [a]
    drop ([Dom ()] -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length [Dom ()]
    is) [Dom ([Char], Type)]
    tel) (NamedArg Expr
    arg NamedArg Expr -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. a -> [a] -> [a]
    : [NamedArg Expr]
    args)
                  ImplicitInsertion
    BadImplicits   -> (NamedArg Expr
    arg NamedArg Expr -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. a -> [a] -> [a]
    : [NamedArg Expr]
    args, [])  -- fail later in checkHeadApplication
                  NoSuchName{}   -> (NamedArg Expr
    arg NamedArg Expr -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. a -> [a] -> [a]
    : [NamedArg Expr]
    args, [])  -- ditto

              ([NamedArg Expr]
    macroArgs, [NamedArg Expr]
    otherArgs) = [Dom ([Char], Type)]
    -> [NamedArg Expr] -> ([NamedArg Expr], [NamedArg Expr])
    makeArgs [Dom ([Char], Type)]
    argTel [NamedArg Expr]
    args
              unq :: Expr -> Expr
    unq = AppInfo -> Expr -> NamedArg Expr -> Expr
    A.App (Range -> AppInfo
    A.defaultAppInfo (Range -> AppInfo) -> Range -> AppInfo
    forall a b. (a -> b) -> a -> b
    $ QName -> [NamedArg Expr] -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange QName
    x [NamedArg Expr]
    args) (ExprInfo -> Expr
    A.Unquote ExprInfo
    A.exprNoRange) (NamedArg Expr -> Expr) -> (Expr -> NamedArg Expr) -> Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Expr -> NamedArg Expr
    forall a. a -> NamedArg a
    defaultNamedArg

              desugared :: Expr
    desugared = Expr -> [NamedArg Expr] -> Expr
    A.app (Expr -> Expr
    unq (Expr -> Expr) -> Expr -> Expr
    forall a b. (a -> b) -> a -> b
    $ AppView -> Expr
    unAppView (AppView -> Expr) -> AppView -> Expr
    forall a b. (a -> b) -> a -> b
    $ Expr -> [NamedArg Expr] -> AppView
    forall arg. Expr -> [NamedArg arg] -> AppView' arg
    Application (QName -> Expr
    A.Def QName
    x) ([NamedArg Expr] -> AppView) -> [NamedArg Expr] -> AppView
    forall a b. (a -> b) -> a -> b
    $ [NamedArg Expr]
    macroArgs) [NamedArg Expr]
    otherArgs

          Comparison -> Expr -> Type -> TCM Term
    checkExpr' Comparison
    cmp Expr
    desugared Type
    t

        -- Subcase: unquote
        A.Unquote ExprInfo
    _
          | [NamedArg Expr
    arg] <- [NamedArg Expr]
    args -> do
              (MetaId
    _, Term
    hole) <- RunMetaOccursCheck -> Comparison -> Type -> TCMT IO (MetaId, Term)
    forall (m :: * -> *).
    MonadMetaSolver m =>
    RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term)
    newValueMeta RunMetaOccursCheck
    RunMetaOccursCheck Comparison
    CmpLeq Type
    t
              Expr -> Term -> Type -> TCMT IO ()
    unquoteM (NamedArg Expr -> Expr
    forall a. NamedArg a -> a
    namedArg NamedArg Expr
    arg) Term
    hole Type
    t
              Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return Term
    hole
          | NamedArg Expr
    arg : [NamedArg Expr]
    args <- [NamedArg Expr]
    args -> do
              -- Example: unquote v a b : A
              --  Create meta H : (x : X) (y : Y x) → Z x y for the hole
              --  Check a : X, b : Y a
              --  Unify Z a b == A
              --  Run the tactic on H
              Tele (Dom Type)
    tel    <- [NamedArg Expr] -> TCM (Tele (Dom Type))
    forall a. [Arg a] -> TCM (Tele (Dom Type))
    metaTel [NamedArg Expr]
    args                    -- (x : X) (y : Y x)
              Type
    target <- Tele (Dom Type) -> TCMT IO Type -> TCMT IO Type
    forall b (m :: * -> *) a.
    (AddContext b, MonadAddContext m) =>
    b -> m a -> m a
    addContext Tele (Dom Type)
    tel TCMT IO Type
    newTypeMeta_      -- Z x y
              let holeType :: Type
    holeType = Tele (Dom Type) -> Type -> Type
    telePi_ Tele (Dom Type)
    tel Type
    target         -- (x : X) (y : Y x) → Z x y
              (Just Args
    vs, Tele (Dom Type)
    EmptyTel) <- (Elims -> Maybe Args)
    -> (Elims, Tele (Dom Type)) -> (Maybe Args, Tele (Dom Type))
    forall a c b. (a -> c) -> (a, b) -> (c, b)
    mapFst Elims -> Maybe Args
    forall a. [Elim' a] -> Maybe [Arg a]
    allApplyElims ((Elims, Tele (Dom Type)) -> (Maybe Args, Tele (Dom Type)))
    -> TCMT IO (Elims, Tele (Dom Type))
    -> TCMT IO (Maybe Args, Tele (Dom Type))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Tele (Dom Type)
    -> TCMT IO (Elims, Tele (Dom Type))
    checkArguments_ Comparison
    CmpLeq ExpandHidden
    ExpandLast ([NamedArg Expr] -> Range
    forall a. HasRange a => a -> Range
    getRange [NamedArg Expr]
    args) [NamedArg Expr]
    args Tele (Dom Type)
    tel
                                                        -- a b : (x : X) (y : Y x)
              let rho :: Substitution' Term
    rho = [Term] -> [Term]
    forall a. [a] -> [a]
    reverse ((Arg Term -> Term) -> Args -> [Term]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Term
    forall e. Arg e -> e
    unArg Args
    vs) [Term] -> Substitution' Term -> Substitution' Term
    forall a. DeBruijn a => [a] -> Substitution' a -> Substitution' a
    ++# Substitution' Term
    forall a. Substitution' a
    IdS  -- [x := a, y := b]
              Type -> Type -> TCMT IO ()
    forall (m :: * -> *). MonadConversion m => Type -> Type -> m ()
    equalType (Substitution' (SubstArg Type) -> Type -> Type
    forall a. Subst a => Substitution' (SubstArg a) -> a -> a
    applySubst Substitution' Term
    Substitution' (SubstArg Type)
    rho Type
    target) Type
    t       -- Z a b == A
              (MetaId
    _, Term
    hole) <- RunMetaOccursCheck -> Comparison -> Type -> TCMT IO (MetaId, Term)
    forall (m :: * -> *).
    MonadMetaSolver m =>
    RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term)
    newValueMeta RunMetaOccursCheck
    RunMetaOccursCheck Comparison
    CmpLeq Type
    holeType
              Expr -> Term -> Type -> TCMT IO ()
    unquoteM (NamedArg Expr -> Expr
    forall a. NamedArg a -> a
    namedArg NamedArg Expr
    arg) Term
    hole Type
    holeType
              Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    apply Term
    hole Args
    vs
          where
            metaTel :: [Arg a] -> TCM Telescope
            metaTel :: forall a. [Arg a] -> TCM (Tele (Dom Type))
    metaTel []           = Tele (Dom Type) -> TCM (Tele (Dom Type))
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Tele (Dom Type)
    forall a. Tele a
    EmptyTel
            metaTel (Arg a
    arg : [Arg a]
    args) = do
              Type
    a <- TCMT IO Type
    newTypeMeta_
              let dom :: Dom Type
    dom = Type
    a Type -> Dom' Term a -> Dom Type
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ Arg a -> Dom' Term a
    forall a. Arg a -> Dom a
    domFromArg Arg a
    arg
              Dom Type -> Abs (Tele (Dom Type)) -> Tele (Dom Type)
    forall a. a -> Abs (Tele a) -> Tele a
    ExtendTel Dom Type
    dom (Abs (Tele (Dom Type)) -> Tele (Dom Type))
    -> (Tele (Dom Type) -> Abs (Tele (Dom Type)))
    -> Tele (Dom Type)
    -> Tele (Dom Type)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Char] -> Tele (Dom Type) -> Abs (Tele (Dom Type))
    forall a. [Char] -> a -> Abs a
    Abs [Char]
    "x" (Tele (Dom Type) -> Tele (Dom Type))
    -> TCM (Tele (Dom Type)) -> TCM (Tele (Dom Type))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
                ([Char], Dom Type)
    -> TCM (Tele (Dom Type)) -> TCM (Tele (Dom Type))
    forall b (m :: * -> *) a.
    (AddContext b, MonadAddContext m) =>
    b -> m a -> m a
    addContext ([Char]
    "x" :: String, Dom Type
    dom) ([Arg a] -> TCM (Tele (Dom Type))
    forall a. [Arg a] -> TCM (Tele (Dom Type))
    metaTel [Arg a]
    args)

        -- Subcase: defined symbol or variable.
        Expr
    _ -> do
          Term
    v <- Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    e Type
    t Expr
    hd [NamedArg Expr]
    args
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.app" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "checkApplication: checkHeadApplication returned"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "v = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Term
    v
            ]
          Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return Term
    v

    -- | Precondition: @Application hd args = appView e@.
    inferApplication :: ExpandHidden -> A.Expr -> A.Args -> A.Expr -> TCM (Term, Type)
    inferApplication :: ExpandHidden -> Expr -> [NamedArg Expr] -> Expr -> TCM (Term, Type)
    inferApplication ExpandHidden
    exh Expr
    hd [NamedArg Expr]
    args Expr
    e | Bool -> Bool
    not (Expr -> Bool
    defOrVar Expr
    hd) = do
      Type
    t <- TCMT IO Type -> TCMT IO Type
    forall (m :: * -> *) a.
    (MonadTCEnv m, HasOptions m, MonadDebug m) =>
    m a -> m a
    workOnTypes (TCMT IO Type -> TCMT IO Type) -> TCMT IO Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Type
    newTypeMeta_
      Term
    v <- Comparison -> Expr -> Type -> TCM Term
    checkExpr' Comparison
    CmpEq Expr
    e Type
    t
      (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    t)
    inferApplication ExpandHidden
    exh Expr
    hd [NamedArg Expr]
    args Expr
    e = TCM (Term, Type) -> TCM (Term, Type)
    forall a. TCM a -> TCM a
    postponeInstanceConstraints (TCM (Term, Type) -> TCM (Term, Type))
    -> TCM (Term, Type) -> TCM (Term, Type)
    forall a b. (a -> b) -> a -> b
    $ do
      SortKit{QName
    IsFibrant -> QName
    nameOfSetOmega :: SortKit -> IsFibrant -> QName
    nameOfSSet :: SortKit -> QName
    nameOfProp :: SortKit -> QName
    nameOfSet :: SortKit -> QName
    nameOfSetOmega :: IsFibrant -> QName
    nameOfSSet :: QName
    nameOfProp :: QName
    nameOfSet :: QName
    ..} <- TCMT IO SortKit
    forall (m :: * -> *). HasBuiltins m => m SortKit
    sortKit
      case Expr -> Expr
    unScope Expr
    hd of
        A.Proj ProjOrigin
    o AmbiguousQName
    p | AmbiguousQName -> Bool
    isAmbiguous AmbiguousQName
    p -> Expr
    -> ProjOrigin -> List1 QName -> [NamedArg Expr] -> TCM (Term, Type)
    inferProjApp Expr
    e ProjOrigin
    o (AmbiguousQName -> List1 QName
    unAmbQ AmbiguousQName
    p) [NamedArg Expr]
    args
        A.Def' QName
    x Suffix
    s | QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfSet      -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSet Expr
    e QName
    x Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    x Suffix
    s | QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfProp     -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferProp Expr
    e QName
    x Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    x Suffix
    s | QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfSSet     -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSSet Expr
    e QName
    x Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    x Suffix
    s | QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == IsFibrant -> QName
    nameOfSetOmega IsFibrant
    IsFibrant -> Expr
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferSetOmega Expr
    e QName
    x IsFibrant
    IsFibrant Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    x Suffix
    s | QName
    x QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == IsFibrant -> QName
    nameOfSetOmega IsFibrant
    IsStrict  -> Expr
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferSetOmega Expr
    e QName
    x IsFibrant
    IsStrict Suffix
    s [NamedArg Expr]
    args
        Expr
    _ -> do
          (Elims -> Term
    f, Type
    t0) <- Expr -> TCM (Elims -> Term, Type)
    inferHead Expr
    hd
          let r :: Range
    r = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    hd
          Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    res <- ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> TCM
          (Either
             (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall a b. (a -> b) -> a -> b
    $ Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE Comparison
    CmpEq ExpandHidden
    exh (Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    hd) [NamedArg Expr]
    args Type
    t0 Maybe Type
    forall a. Maybe a
    Nothing
          case Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    res of
            Right st :: ArgsCheckState CheckedTarget
    st@(ACState{acType :: forall a. ArgsCheckState a -> Type
    acType = Type
    t1}) -> (Term -> (Term, Type)) -> TCM Term -> TCM (Term, Type)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (,Type
    t1) (TCM Term -> TCM (Term, Type)) -> TCM Term -> TCM (Term, Type)
    forall a b. (a -> b) -> a -> b
    $ Term -> TCM Term
    forall (m :: * -> *). PureTCM m => Term -> m Term
    unfoldInlined (Term -> TCM Term) -> TCM Term -> TCM Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints Elims -> Term
    f ArgsCheckState CheckedTarget
    st
            Left ArgsCheckState [NamedArg Expr]
    problem -> do
              Type
    t <- TCMT IO Type -> TCMT IO Type
    forall (m :: * -> *) a.
    (MonadTCEnv m, HasOptions m, MonadDebug m) =>
    m a -> m a
    workOnTypes (TCMT IO Type -> TCMT IO Type) -> TCMT IO Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Type
    newTypeMeta_
              Term
    v <- ArgsCheckState [NamedArg Expr]
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    postponeArgs ArgsCheckState [NamedArg Expr]
    problem Comparison
    CmpEq ExpandHidden
    exh Range
    r [NamedArg Expr]
    args Type
    t ((ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term)
    -> (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ ArgsCheckState CheckedTarget
    st -> Term -> TCM Term
    forall (m :: * -> *). PureTCM m => Term -> m Term
    unfoldInlined (Term -> TCM Term) -> TCM Term -> TCM Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints Elims -> Term
    f ArgsCheckState CheckedTarget
    st
              (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    t)

    -----------------------------------------------------------------------------
    -- * Heads
    -----------------------------------------------------------------------------

    inferHeadDef :: ProjOrigin -> QName -> TCM (Elims -> Term, Type)
    inferHeadDef :: ProjOrigin -> QName -> TCM (Elims -> Term, Type)
    inferHeadDef ProjOrigin
    o QName
    x = do
      -- Andreas, 2022-03-07, issue #5809: don't drop parameters of irrelevant projections.
      Maybe Projection
    proj <- QName -> TCMT IO (Maybe Projection)
    forall (m :: * -> *).
    HasConstInfo m =>
    QName -> m (Maybe Projection)
    isRelevantProjection QName
    x
      Relevance
    rel  <- ArgInfo -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance (ArgInfo -> Relevance)
    -> (Definition -> ArgInfo) -> Definition -> Relevance
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Definition -> ArgInfo
    defArgInfo (Definition -> Relevance)
    -> TCMT IO Definition -> TCMT IO Relevance
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    x
      let app :: Args -> Term
    app =
            case Maybe Projection
    proj of
              Maybe Projection
    Nothing -> \ Args
    args -> QName -> Elims -> Term
    Def QName
    x (Elims -> Term) -> Elims -> Term
    forall a b. (a -> b) -> a -> b
    $ (Arg Term -> Elim) -> Args -> Elims
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply Args
    args
              Just Projection
    p  -> \ Args
    args -> Projection -> ProjOrigin -> Relevance -> Args -> Term
    projDropParsApply Projection
    p ProjOrigin
    o Relevance
    rel Args
    args
      (Term -> Elims -> Term) -> (Term, Type) -> (Elims -> Term, Type)
    forall a c b. (a -> c) -> (a, b) -> (c, b)
    mapFst Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    applyE ((Term, Type) -> (Elims -> Term, Type))
    -> TCM (Term, Type) -> TCM (Elims -> Term, Type)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Args -> Term) -> QName -> TCM (Term, Type)
    inferDef Args -> Term
    app QName
    x

    -- | Infer the type of a head thing (variable, function symbol, or constructor).
    --   We return a function that applies the head to arguments.
    --   This is because in case of a constructor we want to drop the parameters.
    inferHead :: A.Expr -> TCM (Elims -> Term, Type)
    inferHead :: Expr -> TCM (Elims -> Term, Type)
    inferHead Expr
    e = do
      case Expr
    e of
        A.Var Name
    x -> do -- traceCall (InferVar x) $ do
          (Term
    u, Dom Type
    a) <- Name -> TCMT IO (Term, Dom Type)
    forall (m :: * -> *).
    (MonadFail m, MonadTCEnv m) =>
    Name -> m (Term, Dom Type)
    getVarInfo Name
    x
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.var" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    hsep
            [ TCMT IO Doc
    "variable" , Name -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Name
    x
            , TCMT IO Doc
    "(" , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Term -> [Char]
    forall a. Show a => a -> [Char]
    show Term
    u) , TCMT IO Doc
    ")"
            , TCMT IO Doc
    "has type:" , Dom Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Dom Type
    a
            ]
          Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Dom Type -> Bool
    forall a. LensRelevance a => a -> Bool
    usableRelevance Dom Type
    a) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
            TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ()) -> TypeError -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Name -> TypeError
    VariableIsIrrelevant Name
    x
          -- Andreas, 2019-06-18, LAIM 2019, issue #3855:
          -- Conor McBride style quantity judgement:
          -- The available quantity for variable x must be below
          -- the required quantity to construct the term x.
          -- Note: this whole thing does not work for linearity, where we need some actual arithmetics.
          TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM ((Dom Type -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity Dom Type
    a Quantity -> Quantity -> Bool
    `moreQuantity`) (Quantity -> Bool) -> TCMT IO Quantity -> TCMT IO Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (TCEnv -> Quantity) -> TCMT IO Quantity
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
            TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ()) -> TypeError -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Name -> TypeError
    VariableIsErased Name
    x

          Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (Dom Type -> Bool
    forall a. LensCohesion a => a -> Bool
    usableCohesion Dom Type
    a) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
            TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ()) -> TypeError -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Name -> Cohesion -> TypeError
    VariableIsOfUnusableCohesion Name
    x (Dom Type -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion Dom Type
    a)

          (Elims -> Term, Type) -> TCM (Elims -> Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    applyE Term
    u, Dom Type -> Type
    forall t e. Dom' t e -> e
    unDom Dom Type
    a)

        A.Def QName
    x  -> ProjOrigin -> QName -> TCM (Elims -> Term, Type)
    inferHeadDef ProjOrigin
    ProjPrefix QName
    x
        A.Def'{} -> TCM (Elims -> Term, Type)
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- handled in checkHeadApplication and inferApplication

        A.Proj ProjOrigin
    o AmbiguousQName
    ambP | Just QName
    d <- AmbiguousQName -> Maybe QName
    getUnambiguous AmbiguousQName
    ambP -> ProjOrigin -> QName -> TCM (Elims -> Term, Type)
    inferHeadDef ProjOrigin
    o QName
    d
        A.Proj{} -> TCM (Elims -> Term, Type)
    forall a. HasCallStack => a
    __IMPOSSIBLE__ -- inferHead will only be called on unambiguous projections

        A.Con AmbiguousQName
    ambC | Just QName
    c <- AmbiguousQName -> Maybe QName
    getUnambiguous AmbiguousQName
    ambC -> do

          -- Constructors are polymorphic internally.
          -- So, when building the constructor term
          -- we should throw away arguments corresponding to parameters.

          -- First, inferDef will try to apply the constructor
          -- to the free parameters of the current context. We ignore that.
          ConHead
    con <- (SigError -> TCMT IO ConHead)
    -> TCMT IO (Either SigError ConHead) -> TCMT IO ConHead
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> m (Either a b) -> m b
    fromRightM (([Char] -> TCMT IO ConHead)
    -> TCMT IO ConHead -> SigError -> TCMT IO ConHead
    forall a. ([Char] -> a) -> a -> SigError -> a
    sigError [Char] -> TCMT IO ConHead
    forall (m :: * -> *) a.
    (HasCallStack, MonadDebug m) =>
    [Char] -> m a
    __IMPOSSIBLE_VERBOSE__ (TypeError -> TCMT IO ConHead
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ConHead) -> TypeError -> TCMT IO ConHead
    forall a b. (a -> b) -> a -> b
    $ QName -> TypeError
    AbstractConstructorNotInScope QName
    c)) (TCMT IO (Either SigError ConHead) -> TCMT IO ConHead)
    -> TCMT IO (Either SigError ConHead) -> TCMT IO ConHead
    forall a b. (a -> b) -> a -> b
    $
            QName -> TCMT IO (Either SigError ConHead)
    getOrigConHead QName
    c
          (Term
    u, Type
    a) <- (Args -> Term) -> QName -> TCM (Term, Type)
    inferDef (\ Args
    _ -> ConHead -> ConInfo -> Elims -> Term
    Con ConHead
    con ConInfo
    ConOCon []) QName
    c

          -- Next get the number of parameters in the current context.
          Constructor{conPars :: Defn -> Nat
    conPars = Nat
    n} <- Definition -> Defn
    theDef (Definition -> Defn) -> TCMT IO Definition -> TCMT IO Defn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Definition -> TCMT IO Definition
    forall (m :: * -> *).
    (Functor m, HasConstInfo m, HasOptions m, ReadTCState m,
     MonadTCEnv m, MonadDebug m) =>
    Definition -> m Definition
    instantiateDef (Definition -> TCMT IO Definition)
    -> TCMT IO Definition -> TCMT IO Definition
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    c)

          [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.term.con" Nat
    7 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [[Char]] -> [Char]
    unwords [QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow QName
    c, [Char]
    "has", Nat -> [Char]
    forall a. Show a => a -> [Char]
    show Nat
    n, [Char]
    "parameters."]

          -- So when applying the constructor throw away the parameters.
          (Elims -> Term, Type) -> TCM (Elims -> Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    applyE Term
    u (Elims -> Term) -> (Elims -> Elims) -> Elims -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Nat -> Elims -> Elims
    forall a. Nat -> [a] -> [a]
    drop Nat
    n, Type
    a)
        A.Con{} -> TCM (Elims -> Term, Type)
    forall a. HasCallStack => a
    __IMPOSSIBLE__  -- inferHead will only be called on unambiguous constructors
        A.QuestionMark MetaInfo
    i InteractionId
    ii -> (Comparison -> Type -> TCMT IO (MetaId, Term))
    -> MetaInfo -> TCM (Elims -> Term, Type)
    inferMeta (InteractionId -> Comparison -> Type -> TCMT IO (MetaId, Term)
    newQuestionMark InteractionId
    ii) MetaInfo
    i
        A.Underscore MetaInfo
    i   -> (Comparison -> Type -> TCMT IO (MetaId, Term))
    -> MetaInfo -> TCM (Elims -> Term, Type)
    inferMeta (RunMetaOccursCheck -> Comparison -> Type -> TCMT IO (MetaId, Term)
    forall (m :: * -> *).
    MonadMetaSolver m =>
    RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term)
    newValueMeta RunMetaOccursCheck
    RunMetaOccursCheck) MetaInfo
    i
        Expr
    e -> do
          (Term
    term, Type
    t) <- Expr -> TCM (Term, Type)
    inferExpr Expr
    e
          (Elims -> Term, Type) -> TCM (Elims -> Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    applyE Term
    term, Type
    t)

    inferDef :: (Args -> Term) -> QName -> TCM (Term, Type)
    inferDef :: (Args -> Term) -> QName -> TCM (Term, Type)
    inferDef Args -> Term
    mkTerm QName
    x =
      Call -> TCM (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. MonadTrace m => Call -> m a -> m a
    traceCall (QName -> Call
    InferDef QName
    x) (TCM (Term, Type) -> TCM (Term, Type))
    -> TCM (Term, Type) -> TCM (Term, Type)
    forall a b. (a -> b) -> a -> b
    $ do
        -- getConstInfo retrieves the *absolute* (closed) type of x
        -- instantiateDef relativizes it to the current context
        Definition
    d0 <- QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    x
        Definition
    d  <- Definition -> TCMT IO Definition
    forall (m :: * -> *).
    (Functor m, HasConstInfo m, HasOptions m, ReadTCState m,
     MonadTCEnv m, MonadDebug m) =>
    Definition -> m Definition
    instantiateDef Definition
    d0
        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    10 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "inferDef" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    x
        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "  absolute type:    " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc -> TCMT IO Doc
    forall (tcm :: * -> *) a.
    (MonadTCEnv tcm, ReadTCState tcm) =>
    tcm a -> tcm a
    inTopContext (Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM (Type -> TCMT IO Doc) -> Type -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Definition -> Type
    defType Definition
    d0)
        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "  instantiated type:" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM (Definition -> Type
    defType Definition
    d)
        -- Irrelevant defs are only allowed in irrelevant position.
        -- Erased defs are only allowed in erased position (see #3855).
        QName -> Definition -> TCMT IO ()
    checkModality QName
    x Definition
    d
        case Definition -> Defn
    theDef Definition
    d of
          GeneralizableVar{} -> do
            -- Generalizable variables corresponds to metas created
            -- at the point where they should be generalized. Module parameters
            -- have already been applied to the meta, so we don't have to do that
            -- here.
            GeneralizedValue
    val <- GeneralizedValue -> Maybe GeneralizedValue -> GeneralizedValue
    forall a. a -> Maybe a -> a
    fromMaybe GeneralizedValue
    forall a. HasCallStack => a
    __IMPOSSIBLE__ (Maybe GeneralizedValue -> GeneralizedValue)
    -> TCMT IO (Maybe GeneralizedValue) -> TCMT IO GeneralizedValue
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Lens' (Maybe GeneralizedValue) TCEnv
    -> TCMT IO (Maybe GeneralizedValue)
    forall (m :: * -> *) a. MonadTCEnv m => Lens' a TCEnv -> m a
    viewTC ((Map QName GeneralizedValue -> f (Map QName GeneralizedValue))
    -> TCEnv -> f TCEnv
    Lens' (Map QName GeneralizedValue) TCEnv
    eGeneralizedVars ((Map QName GeneralizedValue -> f (Map QName GeneralizedValue))
     -> TCEnv -> f TCEnv)
    -> ((Maybe GeneralizedValue -> f (Maybe GeneralizedValue))
        -> Map QName GeneralizedValue -> f (Map QName GeneralizedValue))
    -> (Maybe GeneralizedValue -> f (Maybe GeneralizedValue))
    -> TCEnv
    -> f TCEnv
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . QName
    -> Lens' (Maybe GeneralizedValue) (Map QName GeneralizedValue)
    forall k v. Ord k => k -> Lens' (Maybe v) (Map k v)
    key QName
    x)
            Substitution' Term
    sub <- CheckpointId -> TCMT IO (Substitution' Term)
    forall (tcm :: * -> *).
    MonadTCEnv tcm =>
    CheckpointId -> tcm (Substitution' Term)
    checkpointSubstitution (GeneralizedValue -> CheckpointId
    genvalCheckpoint GeneralizedValue
    val)
            let (Term
    v, Type
    t) = Substitution' (SubstArg (Term, Type))
    -> (Term, Type) -> (Term, Type)
    forall a. Subst a => Substitution' (SubstArg a) -> a -> a
    applySubst Substitution' Term
    Substitution' (SubstArg (Term, Type))
    sub (GeneralizedValue -> Term
    genvalTerm GeneralizedValue
    val, GeneralizedValue -> Type
    genvalType GeneralizedValue
    val)
            Args -> Type -> Term -> TCMT IO ()
    debug [] Type
    t Term
    v
            (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    t)
          Defn
    _ -> do
            -- since x is considered living in the top-level, we have to
            -- apply it to the current context
            Args
    vs <- QName -> TCMT IO Args
    forall (m :: * -> *).
    (Functor m, HasConstInfo m, HasOptions m, ReadTCState m,
     MonadTCEnv m, MonadDebug m) =>
    QName -> m Args
    freeVarsToApply QName
    x
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "  free vars:" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Semigroup (m Doc), Foldable t) =>
    t (m Doc) -> m Doc
    prettyList_ ((Arg Term -> TCMT IO Doc) -> Args -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Args
    vs)
            let t :: Type
    t = Definition -> Type
    defType Definition
    d
                v :: Term
    v = Args -> Term
    mkTerm Args
    vs -- applies x to vs, dropping parameters

            -- Andrea 2019-07-16, Check that the supplied arguments
            -- respect the cohesion modalities of the current context.
            -- Cohesion is purely based on left-division, so it does not
            -- rely on "position" like Relevance/Quantity.
            Args -> TCMT IO ()
    checkCohesionArgs Args
    vs

            Args -> Type -> Term -> TCMT IO ()
    debug Args
    vs Type
    t Term
    v
            (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    t)
      where
        debug :: Args -> Type -> Term -> TCM ()
        debug :: Args -> Type -> Term -> TCMT IO ()
    debug Args
    vs Type
    t Term
    v = do
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    60 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
            TCMT IO Doc
    "freeVarsToApply to def " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    hsep ((Arg Term -> TCMT IO Doc) -> Args -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map ([Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc)
    -> (Arg Term -> [Char]) -> Arg Term -> TCMT IO Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> [Char]
    forall a. Show a => a -> [Char]
    show) Args
    vs)
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.def" Nat
    10 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "inferred def " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    x TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    hsep ((Arg Term -> TCMT IO Doc) -> Args -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Args
    vs)
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    ":" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "-->" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Term
    v ]

    checkCohesionArgs :: Args -> TCM ()
    checkCohesionArgs :: Args -> TCMT IO ()
    checkCohesionArgs Args
    vs = do
      let
        vmap :: VarMap
        vmap :: VarMap
    vmap = Args -> VarMap
    forall a c t. (IsVarSet a c, Singleton Nat c, Free t) => t -> c
    freeVars Args
    vs

      -- we iterate over all vars in the context and their ArgInfo,
      -- checking for each that "vs" uses them as allowed.
      Args
    as <- TCMT IO Args
    forall (m :: * -> *). (Applicative m, MonadTCEnv m) => m Args
    getContextArgs
      Args -> (Arg Term -> TCMT IO ()) -> TCMT IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    t a -> (a -> m b) -> m ()
    forM_ Args
    as ((Arg Term -> TCMT IO ()) -> TCMT IO ())
    -> (Arg Term -> TCMT IO ()) -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ \ (Arg ArgInfo
    avail Term
    t) -> do
        let m :: Maybe Modality
    m = do
              Nat
    v <- Term -> Maybe Nat
    forall a. DeBruijn a => a -> Maybe Nat
    deBruijnView Term
    t
              VarOcc' MetaSet -> Modality
    forall a. VarOcc' a -> Modality
    varModality (VarOcc' MetaSet -> Modality)
    -> Maybe (VarOcc' MetaSet) -> Maybe Modality
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Nat -> VarMap -> Maybe (VarOcc' MetaSet)
    forall a. Nat -> VarMap' a -> Maybe (VarOcc' a)
    lookupVarMap Nat
    v VarMap
    vmap
        Maybe Modality -> (Modality -> TCMT IO ()) -> TCMT IO ()
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
    whenJust Maybe Modality
    m ((Modality -> TCMT IO ()) -> TCMT IO ())
    -> (Modality -> TCMT IO ()) -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ \ Modality
    used -> do
            Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (ArgInfo -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion ArgInfo
    avail Cohesion -> Cohesion -> Bool
    `moreCohesion` Modality -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion Modality
    used) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
               (Doc -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    Doc -> m a
    genericDocError (Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<<) (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    fsep ([TCMT IO Doc] -> TCMT IO Doc) -> [TCMT IO Doc] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $
                    [TCMT IO Doc
    "Variable" , Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Term
    t]
                 [TCMT IO Doc] -> [TCMT IO Doc] -> [TCMT IO Doc]
    forall a. [a] -> [a] -> [a]
    ++ [Char] -> [TCMT IO Doc]
    forall (m :: * -> *). Applicative m => [Char] -> [m Doc]
    pwords [Char]
    "is used as" [TCMT IO Doc] -> [TCMT IO Doc] -> [TCMT IO Doc]
    forall a. [a] -> [a] -> [a]
    ++ [[Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Cohesion -> [Char]
    forall a. Show a => a -> [Char]
    show (Cohesion -> [Char]) -> Cohesion -> [Char]
    forall a b. (a -> b) -> a -> b
    $ Modality -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion Modality
    used]
                 [TCMT IO Doc] -> [TCMT IO Doc] -> [TCMT IO Doc]
    forall a. [a] -> [a] -> [a]
    ++ [Char] -> [TCMT IO Doc]
    forall (m :: * -> *). Applicative m => [Char] -> [m Doc]
    pwords [Char]
    "but only available as" [TCMT IO Doc] -> [TCMT IO Doc] -> [TCMT IO Doc]
    forall a. [a] -> [a] -> [a]
    ++ [[Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Cohesion -> [Char]
    forall a. Show a => a -> [Char]
    show (Cohesion -> [Char]) -> Cohesion -> [Char]
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Cohesion
    forall a. LensCohesion a => a -> Cohesion
    getCohesion ArgInfo
    avail]

    -- | The second argument is the definition of the first.
    --   Returns 'Nothing' if ok, otherwise the error message.
    checkRelevance' :: QName -> Definition -> TCM (Maybe TypeError)
    checkRelevance' :: QName -> Definition -> TCM (Maybe TypeError)
    checkRelevance' QName
    x Definition
    def = do
      case Definition -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance Definition
    def of
        Relevance
    Relevant -> Maybe TypeError -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe TypeError
    forall a. Maybe a
    Nothing -- relevance functions can be used in any context.
        Relevance
    drel -> do
          -- Andreas,, 2018-06-09, issue #2170
          -- irrelevant projections are only allowed if --irrelevant-projections
          TCMT IO Bool
    -> TCM (Maybe TypeError)
    -> TCM (Maybe TypeError)
    -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => m Bool -> m a -> m a -> m a
    ifM (Bool -> TCMT IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe Projection -> Bool
    forall a. Maybe a -> Bool
    isJust (Maybe Projection -> Bool) -> Maybe Projection -> Bool
    forall a b. (a -> b) -> a -> b
    $ Defn -> Maybe Projection
    isProjection_ (Defn -> Maybe Projection) -> Defn -> Maybe Projection
    forall a b. (a -> b) -> a -> b
    $ Definition -> Defn
    theDef Definition
    def) TCMT IO Bool -> TCMT IO Bool -> TCMT IO Bool
    forall (m :: * -> *). Monad m => m Bool -> m Bool -> m Bool
    `and2M`
               (Bool -> Bool
    not (Bool -> Bool) -> (PragmaOptions -> Bool) -> PragmaOptions -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .PragmaOptions -> Bool
    optIrrelevantProjections (PragmaOptions -> Bool) -> TCMT IO PragmaOptions -> TCMT IO Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO PragmaOptions
    forall (m :: * -> *). HasOptions m => m PragmaOptions
    pragmaOptions)) {-then-} TCM (Maybe TypeError)
    needIrrProj {-else-} (TCM (Maybe TypeError) -> TCM (Maybe TypeError))
    -> TCM (Maybe TypeError) -> TCM (Maybe TypeError)
    forall a b. (a -> b) -> a -> b
    $ do
            Relevance
    rel <- (TCEnv -> Relevance) -> TCMT IO Relevance
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> Relevance
    forall a. LensRelevance a => a -> Relevance
    getRelevance
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.irr" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
              [ TCMT IO Doc
    "declaration relevance =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Relevance -> [Char]
    forall a. Show a => a -> [Char]
    show Relevance
    drel)
              , TCMT IO Doc
    "context     relevance =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Relevance -> [Char]
    forall a. Show a => a -> [Char]
    show Relevance
    rel)
              ]
            Maybe TypeError -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe TypeError -> TCM (Maybe TypeError))
    -> Maybe TypeError -> TCM (Maybe TypeError)
    forall a b. (a -> b) -> a -> b
    $ if (Relevance
    drel Relevance -> Relevance -> Bool
    `moreRelevant` Relevance
    rel) then Maybe TypeError
    forall a. Maybe a
    Nothing else TypeError -> Maybe TypeError
    forall a. a -> Maybe a
    Just (TypeError -> Maybe TypeError) -> TypeError -> Maybe TypeError
    forall a b. (a -> b) -> a -> b
    $ QName -> TypeError
    DefinitionIsIrrelevant QName
    x
      where
      needIrrProj :: TCM (Maybe TypeError)
    needIrrProj = TypeError -> Maybe TypeError
    forall a. a -> Maybe a
    Just (TypeError -> Maybe TypeError)
    -> (Doc -> TypeError) -> Doc -> Maybe TypeError
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> Maybe TypeError) -> TCMT IO Doc -> TCM (Maybe TypeError)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> do
        [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep [ TCMT IO Doc
    "Projection " , QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    x, TCMT IO Doc
    " is irrelevant."
            , TCMT IO Doc
    " Turn on option --irrelevant-projections to use it (unsafe)."
            ]

    -- | The second argument is the definition of the first.
    --   Returns 'Nothing' if ok, otherwise the error message.
    checkQuantity' :: QName -> Definition -> TCM (Maybe TypeError)
    checkQuantity' :: QName -> Definition -> TCM (Maybe TypeError)
    checkQuantity' QName
    x Definition
    def = do
      case Definition -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity Definition
    def of
        dq :: Quantity
    dq@Quantityω{} -> do
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.irr" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "declaration quantity =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Quantity -> [Char]
    forall a. Show a => a -> [Char]
    show Quantity
    dq)
            -- , "context     quantity =" <+> text (show q)
            ]
          Maybe TypeError -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe TypeError
    forall a. Maybe a
    Nothing -- Abundant definitions can be used in any context.
        Quantity
    dq -> do
          Quantity
    q <- (TCEnv -> Quantity) -> TCMT IO Quantity
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> Quantity
    forall a. LensQuantity a => a -> Quantity
    getQuantity
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.irr" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "declaration quantity =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Quantity -> [Char]
    forall a. Show a => a -> [Char]
    show Quantity
    dq)
            , TCMT IO Doc
    "context     quantity =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Quantity -> [Char]
    forall a. Show a => a -> [Char]
    show Quantity
    q)
            ]
          Maybe TypeError -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe TypeError -> TCM (Maybe TypeError))
    -> Maybe TypeError -> TCM (Maybe TypeError)
    forall a b. (a -> b) -> a -> b
    $ if (Quantity
    dq Quantity -> Quantity -> Bool
    `moreQuantity` Quantity
    q) then Maybe TypeError
    forall a. Maybe a
    Nothing else TypeError -> Maybe TypeError
    forall a. a -> Maybe a
    Just (TypeError -> Maybe TypeError) -> TypeError -> Maybe TypeError
    forall a b. (a -> b) -> a -> b
    $ QName -> TypeError
    DefinitionIsErased QName
    x

    -- | The second argument is the definition of the first.
    checkModality' :: QName -> Definition -> TCM (Maybe TypeError)
    checkModality' :: QName -> Definition -> TCM (Maybe TypeError)
    checkModality' QName
    x Definition
    def = do
      QName -> Definition -> TCM (Maybe TypeError)
    checkRelevance' QName
    x Definition
    def TCM (Maybe TypeError)
    -> (Maybe TypeError -> TCM (Maybe TypeError))
    -> TCM (Maybe TypeError)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \case
        Maybe TypeError
    Nothing    -> QName -> Definition -> TCM (Maybe TypeError)
    checkQuantity' QName
    x Definition
    def
        err :: Maybe TypeError
    err@Just{} -> Maybe TypeError -> TCM (Maybe TypeError)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe TypeError
    err

    -- | The second argument is the definition of the first.
    checkModality :: QName -> Definition -> TCM ()
    checkModality :: QName -> Definition -> TCMT IO ()
    checkModality QName
    x Definition
    def = TCM (Maybe TypeError) -> TCMT IO ()
    forall {m :: * -> *}.
    (MonadTCEnv m, ReadTCState m, MonadError TCErr m) =>
    m (Maybe TypeError) -> m ()
    justToError (TCM (Maybe TypeError) -> TCMT IO ())
    -> TCM (Maybe TypeError) -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ QName -> Definition -> TCM (Maybe TypeError)
    checkModality' QName
    x Definition
    def
      where
      justToError :: m (Maybe TypeError) -> m ()
    justToError m (Maybe TypeError)
    m = m () -> (TypeError -> m ()) -> Maybe TypeError -> m ()
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (() -> m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()) TypeError -> m ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (Maybe TypeError -> m ()) -> m (Maybe TypeError) -> m ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< m (Maybe TypeError)
    m

    -- | @checkHeadApplication e t hd args@ checks that @e@ has type @t@,
    -- assuming that @e@ has the form @hd args@. The corresponding
    -- type-checked term is returned.
    --
    -- If the head term @hd@ is a coinductive constructor, then a
    -- top-level definition @fresh tel = hd args@ (where the clause is
    -- delayed) is added, where @tel@ corresponds to the current
    -- telescope. The returned term is @fresh tel@.
    --
    -- Precondition: The head @hd@ has to be unambiguous, and there should
    -- not be any need to insert hidden lambdas.
    checkHeadApplication :: Comparison -> A.Expr -> Type -> A.Expr -> [NamedArg A.Expr] -> TCM Term
    checkHeadApplication :: Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    e Type
    t Expr
    hd [NamedArg Expr]
    args = do
      SortKit{QName
    IsFibrant -> QName
    nameOfSetOmega :: IsFibrant -> QName
    nameOfSSet :: QName
    nameOfProp :: QName
    nameOfSet :: QName
    nameOfSetOmega :: SortKit -> IsFibrant -> QName
    nameOfSSet :: SortKit -> QName
    nameOfProp :: SortKit -> QName
    nameOfSet :: SortKit -> QName
    ..} <- TCMT IO SortKit
    forall (m :: * -> *). HasBuiltins m => m SortKit
    sortKit
      Maybe QName
    sharp <- (CoinductionKit -> QName) -> Maybe CoinductionKit -> Maybe QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap CoinductionKit -> QName
    nameOfSharp (Maybe CoinductionKit -> Maybe QName)
    -> TCMT IO (Maybe CoinductionKit) -> TCMT IO (Maybe QName)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO (Maybe CoinductionKit)
    coinductionKit
      Maybe QName
    conId  <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtinConId
      Maybe QName
    pOr    <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtinPOr
      Maybe QName
    pComp  <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtinComp
      Maybe QName
    pHComp <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtinHComp
      Maybe QName
    pTrans <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtinTrans
      Maybe QName
    mglue  <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtin_glue
      Maybe QName
    mglueU  <- [Char] -> TCMT IO (Maybe QName)
    forall (m :: * -> *). HasBuiltins m => [Char] -> m (Maybe QName)
    getNameOfConstrained [Char]
    builtin_glueU
      case Expr
    hd of
        A.Def' QName
    c Suffix
    s | QName
    c QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfSet      -> Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkSet Comparison
    cmp Expr
    e Type
    t QName
    c Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    c Suffix
    s | QName
    c QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfProp     -> Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkProp Comparison
    cmp Expr
    e Type
    t QName
    c Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    c Suffix
    s | QName
    c QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    nameOfSSet     -> Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkSSet Comparison
    cmp Expr
    e Type
    t QName
    c Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    c Suffix
    s | QName
    c QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == IsFibrant -> QName
    nameOfSetOmega IsFibrant
    IsFibrant -> Comparison
    -> Expr
    -> Type
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOmega Comparison
    cmp Expr
    e Type
    t QName
    c IsFibrant
    IsFibrant Suffix
    s [NamedArg Expr]
    args
        A.Def' QName
    c Suffix
    s | QName
    c QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == IsFibrant -> QName
    nameOfSetOmega IsFibrant
    IsStrict  -> Comparison
    -> Expr
    -> Type
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOmega Comparison
    cmp Expr
    e Type
    t QName
    c IsFibrant
    IsStrict Suffix
    s [NamedArg Expr]
    args

        -- Type checking #. The # that the user can write will be a Def, but the
        -- sharp we generate in the body of the wrapper is a Con.
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    sharp -> Expr -> Type -> QName -> [NamedArg Expr] -> TCM Term
    checkSharpApplication Expr
    e Type
    t QName
    c [NamedArg Expr]
    args

        -- Cubical primitives
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    pComp -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimComp QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    pHComp -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimHComp QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    pTrans -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimTrans QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    conId -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkConId QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    pOr   -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPOr QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    mglue -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    check_glue QName
    c
        A.Def QName
    c | QName -> Maybe QName
    forall a. a -> Maybe a
    Just QName
    c Maybe QName -> Maybe QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == Maybe QName
    mglueU -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' (Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. a -> Maybe a
    Just ((MaybeRanges -> Args -> Type -> TCMT IO Args)
     -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args))
    -> (MaybeRanges -> Args -> Type -> TCMT IO Args)
    -> Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    check_glueU QName
    c

        Expr
    _ -> TCM Term
    defaultResult
      where
      defaultResult :: TCM Term
      defaultResult :: TCM Term
    defaultResult = Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    forall a. Maybe a
    Nothing
      defaultResult' :: Maybe (MaybeRanges -> Args -> Type -> TCM Args) -> TCM Term
      defaultResult' :: Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args) -> TCM Term
    defaultResult' Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    mk = do
        (Elims -> Term
    f, Type
    t0) <- Expr -> TCM (Elims -> Term, Type)
    inferHead Expr
    hd
        ExpandHidden
    expandLast <- (TCEnv -> ExpandHidden) -> TCMT IO ExpandHidden
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> ExpandHidden
    envExpandLast
        Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    checkArguments Comparison
    cmp ExpandHidden
    expandLast (Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    hd) [NamedArg Expr]
    args Type
    t0 Type
    t ((ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term)
    -> (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ st :: ArgsCheckState CheckedTarget
    st@(ACState MaybeRanges
    rs Elims
    vs [Maybe (Abs Constraint)]
    _ Type
    t1 CheckedTarget
    checkedTarget) -> do
          let check :: Maybe (TCMT IO Args)
    check = do
               MaybeRanges -> Args -> Type -> TCMT IO Args
    k <- Maybe (MaybeRanges -> Args -> Type -> TCMT IO Args)
    mk
               Args
    as <- Elims -> Maybe Args
    forall a. [Elim' a] -> Maybe [Arg a]
    allApplyElims Elims
    vs
               TCMT IO Args -> Maybe (TCMT IO Args)
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (TCMT IO Args -> Maybe (TCMT IO Args))
    -> TCMT IO Args -> Maybe (TCMT IO Args)
    forall a b. (a -> b) -> a -> b
    $ MaybeRanges -> Args -> Type -> TCMT IO Args
    k MaybeRanges
    rs Args
    as Type
    t1
          Elims
    vs <- case Maybe (TCMT IO Args)
    check of
                  Just TCMT IO Args
    ck -> do
                    (Arg Term -> Elim) -> Args -> Elims
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Args -> Elims) -> TCMT IO Args -> TCMT IO Elims
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Args
    ck
                  Maybe (TCMT IO Args)
    Nothing -> do
                    Elims -> TCMT IO Elims
    forall (m :: * -> *) a. Monad m => a -> m a
    return Elims
    vs
          Term
    v <- Term -> TCM Term
    forall (m :: * -> *). PureTCM m => Term -> m Term
    unfoldInlined (Term -> TCM Term) -> TCM Term -> TCM Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints Elims -> Term
    f (ArgsCheckState CheckedTarget
    st { acElims :: Elims
    acElims = Elims
    vs })
          Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    checkedTarget Term
    v Type
    t1 Type
    t

    -- Issue #3019 and #4170: Don't insert trailing implicits when checking arguments to existing
    -- metavariables.
    turnOffExpandLastIfExistingMeta :: A.Expr -> TCM a -> TCM a
    turnOffExpandLastIfExistingMeta :: forall a. Expr -> TCM a -> TCM a
    turnOffExpandLastIfExistingMeta Expr
    hd
      | Bool
    isExistingMeta = TCM a -> TCM a
    forall a. TCM a -> TCM a
    reallyDontExpandLast
      | Bool
    otherwise      = TCM a -> TCM a
    forall a. a -> a
    id
      where
        isExistingMeta :: Bool
    isExistingMeta = Maybe MetaId -> Bool
    forall a. Maybe a -> Bool
    isJust (Maybe MetaId -> Bool) -> Maybe MetaId -> Bool
    forall a b. (a -> b) -> a -> b
    $ MetaInfo -> Maybe MetaId
    A.metaNumber (MetaInfo -> Maybe MetaId) -> Maybe MetaInfo -> Maybe MetaId
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< Expr -> Maybe MetaInfo
    metaInfo Expr
    hd
        metaInfo :: Expr -> Maybe MetaInfo
    metaInfo (A.QuestionMark MetaInfo
    i InteractionId
    _) = MetaInfo -> Maybe MetaInfo
    forall a. a -> Maybe a
    Just MetaInfo
    i
        metaInfo (A.Underscore MetaInfo
    i)     = MetaInfo -> Maybe MetaInfo
    forall a. a -> Maybe a
    Just MetaInfo
    i
        metaInfo (A.ScopedExpr ScopeInfo
    _ Expr
    e)   = Expr -> Maybe MetaInfo
    metaInfo Expr
    e
        metaInfo Expr
    _                    = Maybe MetaInfo
    forall a. Maybe a
    Nothing

    -----------------------------------------------------------------------------
    -- * Spines
    -----------------------------------------------------------------------------

    traceCallE :: Call -> ExceptT e TCM r -> ExceptT e TCM r
    traceCallE :: forall e r. Call -> ExceptT e (TCMT IO) r -> ExceptT e (TCMT IO) r
    traceCallE Call
    call ExceptT e (TCMT IO) r
    m = do
      Either e r
    z <- TCM (Either e r) -> ExceptT e (TCMT IO) (Either e r)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (Either e r) -> ExceptT e (TCMT IO) (Either e r))
    -> TCM (Either e r) -> ExceptT e (TCMT IO) (Either e r)
    forall a b. (a -> b) -> a -> b
    $ Call -> TCM (Either e r) -> TCM (Either e r)
    forall (m :: * -> *) a. MonadTrace m => Call -> m a -> m a
    traceCall Call
    call (TCM (Either e r) -> TCM (Either e r))
    -> TCM (Either e r) -> TCM (Either e r)
    forall a b. (a -> b) -> a -> b
    $ ExceptT e (TCMT IO) r -> TCM (Either e r)
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT ExceptT e (TCMT IO) r
    m
      case Either e r
    z of
        Right r
    e  -> r -> ExceptT e (TCMT IO) r
    forall (m :: * -> *) a. Monad m => a -> m a
    return r
    e
        Left e
    err -> e -> ExceptT e (TCMT IO) r
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError e
    err

    -- | If we've already checked the target type we don't have to call coerce.
    coerce' :: Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' :: Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    NotCheckedTarget           Term
    v Type
    inferred Type
    expected = Comparison -> Term -> Type -> Type -> TCM Term
    forall (m :: * -> *).
    (MonadConversion m, MonadTCM m) =>
    Comparison -> Term -> Type -> Type -> m Term
    coerce Comparison
    cmp Term
    v Type
    inferred Type
    expected
    coerce' Comparison
    cmp (CheckedTarget Maybe ProblemId
    Nothing)    Term
    v Type
    _        Type
    _        = Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return Term
    v
    coerce' Comparison
    cmp (CheckedTarget (Just ProblemId
    pid)) Term
    v Type
    _        Type
    expected = Type -> Term -> ProblemId -> TCM Term
    forall (m :: * -> *).
    (MonadMetaSolver m, MonadFresh Nat m) =>
    Type -> Term -> ProblemId -> m Term
    blockTermOnProblem Type
    expected Term
    v ProblemId
    pid

    -- | Check a list of arguments: @checkArgs args t0 t1@ checks that
    --   @t0 = Delta -> t0'@ and @args : Delta@. Inserts hidden arguments to
    --   make this happen.  Returns the evaluated arguments @vs@, the remaining
    --   type @t0'@ (which should be a subtype of @t1@) and any constraints @cs@
    --   that have to be solved for everything to be well-formed.

    checkArgumentsE :: Comparison -> ExpandHidden -> Range -> [NamedArg A.Expr] -> Type -> Maybe Type ->
                       ExceptT (ArgsCheckState [NamedArg A.Expr]) TCM (ArgsCheckState CheckedTarget)
    checkArgumentsE :: Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE = CheckedTarget
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE' CheckedTarget
    NotCheckedTarget

    checkArgumentsE'
      :: CheckedTarget     -- ^ Have we already checked the target?
      -> Comparison        -- ^ Comparison to use if checking target type
      -> ExpandHidden      -- ^ Insert trailing hidden arguments?
      -> Range             -- ^ Range of the function.
      -> [NamedArg A.Expr] -- ^ Arguments.
      -> Type              -- ^ Type of the function.
      -> Maybe Type        -- ^ Type of the application.
      -> ExceptT (ArgsCheckState [NamedArg A.Expr]) TCM (ArgsCheckState CheckedTarget)

    -- Case: no arguments, do not insert trailing hidden arguments: We are done.
    checkArgumentsE' :: CheckedTarget
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE' CheckedTarget
    chk Comparison
    cmp ExpandHidden
    exh Range
    _ [] Type
    t0 Maybe Type
    _ | ExpandHidden -> Bool
    isDontExpandLast ExpandHidden
    exh = ArgsCheckState CheckedTarget
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ArgsCheckState CheckedTarget
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ArgsCheckState CheckedTarget
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> CheckedTarget
    -> ArgsCheckState CheckedTarget
    forall a.
    MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> a
    -> ArgsCheckState a
    ACState [] [] [] Type
    t0 CheckedTarget
    chk

    -- Case: no arguments, but need to insert trailing hiddens.
    checkArgumentsE' CheckedTarget
    chk Comparison
    cmp ExpandHidden
    _ExpandLast Range
    r [] Type
    t0 Maybe Type
    mt1 =
        Call
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall e r. Call -> ExceptT e (TCMT IO) r -> ExceptT e (TCMT IO) r
    traceCallE (Range -> [NamedArg Expr] -> Type -> Maybe Type -> Call
    CheckArguments Range
    r [] Type
    t0 Maybe Type
    mt1) (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ do
          Maybe Term
    mt1' <- (Type -> TCM Term) -> Maybe Type -> TCM (Maybe Term)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    traverse (Type -> Term
    forall t a. Type'' t a -> a
    unEl (Type -> Term) -> (Type -> TCMT IO Type) -> Type -> TCM Term
    forall (m :: * -> *) b c a.
    Functor m =>
    (b -> c) -> (a -> m b) -> a -> m c
    <.> Type -> TCMT IO Type
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce) Maybe Type
    mt1
          (Args
    us, Type
    t) <- Nat -> (Hiding -> Bool) -> Type -> TCM (Args, Type)
    forall (m :: * -> *).
    (PureTCM m, MonadMetaSolver m, MonadTCM m) =>
    Nat -> (Hiding -> Bool) -> Type -> m (Args, Type)
    implicitArgs (-Nat
    1) (Maybe Term -> Hiding -> Bool
    expand Maybe Term
    mt1') Type
    t0
          ArgsCheckState CheckedTarget -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ArgsCheckState CheckedTarget
     -> TCM (ArgsCheckState CheckedTarget))
    -> ArgsCheckState CheckedTarget
    -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> CheckedTarget
    -> ArgsCheckState CheckedTarget
    forall a.
    MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> a
    -> ArgsCheckState a
    ACState (Nat -> Maybe Range -> MaybeRanges
    forall a. Nat -> a -> [a]
    replicate (Args -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Args
    us) Maybe Range
    forall a. Maybe a
    Nothing) ((Arg Term -> Elim) -> Args -> Elims
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply Args
    us) (Nat -> Maybe (Abs Constraint) -> [Maybe (Abs Constraint)]
    forall a. Nat -> a -> [a]
    replicate (Args -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Args
    us) Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing) Type
    t CheckedTarget
    chk
        where
          expand :: Maybe Term -> Hiding -> Bool
    expand (Just (Pi Dom Type
    dom Abs Type
    _)) Hiding
    Hidden     = Bool -> Bool
    not (Dom Type -> Bool
    forall a. LensHiding a => a -> Bool
    hidden Dom Type
    dom)
          expand Maybe Term
    _                 Hiding
    Hidden     = Bool
    True
          expand (Just (Pi Dom Type
    dom Abs Type
    _)) Instance{} = Bool -> Bool
    not (Dom Type -> Bool
    forall a. LensHiding a => a -> Bool
    isInstance Dom Type
    dom)
          expand Maybe Term
    _                 Instance{} = Bool
    True
          expand Maybe Term
    _                 Hiding
    NotHidden  = Bool
    False

    -- Case: argument given.
    checkArgumentsE' CheckedTarget
    chk Comparison
    cmp ExpandHidden
    exh Range
    r args0 :: [NamedArg Expr]
    args0@(arg :: NamedArg Expr
    arg@(Arg ArgInfo
    info Named_ Expr
    e) : [NamedArg Expr]
    args) Type
    t0 Maybe Type
    mt1 =
        Call
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall e r. Call -> ExceptT e (TCMT IO) r -> ExceptT e (TCMT IO) r
    traceCallE (Range -> [NamedArg Expr] -> Type -> Maybe Type -> Call
    CheckArguments Range
    r [NamedArg Expr]
    args0 Type
    t0 Maybe Type
    mt1) (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ do
          TCMT IO () -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO ()
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO ()
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.args" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep
            [ TCMT IO Doc
    "checkArgumentsE"
    --        , "  args0 =" <+> prettyA args0
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
              [ TCMT IO Doc
    "e     =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Named_ Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA Named_ Expr
    e
              , TCMT IO Doc
    "t0    =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t0
              , TCMT IO Doc
    "t1    =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc -> (Type -> TCMT IO Doc) -> Maybe Type -> TCMT IO Doc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe TCMT IO Doc
    "Nothing" Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Maybe Type
    mt1
              ]
            ]
          -- First, insert implicit arguments, depending on current argument @arg@.
          let hx :: Hiding
    hx = ArgInfo -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding ArgInfo
    info  -- hiding of current argument
              mx :: Maybe ArgName
              mx :: Maybe [Char]
    mx = Named_ Expr -> Maybe [Char]
    forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe [Char]
    bareNameOf Named_ Expr
    e    -- name of current argument
              -- do not insert visible arguments
              expand :: Hiding -> [Char] -> Bool
    expand Hiding
    NotHidden [Char]
    y = Bool
    False
              -- insert a hidden argument if arg is not hidden or has different name
              -- insert an instance argument if arg is not instance  or has different name
              expand Hiding
    hy        [Char]
    y = Bool -> Bool
    not (Hiding -> Hiding -> Bool
    forall a b. (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding Hiding
    hy Hiding
    hx) Bool -> Bool -> Bool
    || Bool -> ([Char] -> Bool) -> Maybe [Char] -> Bool
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Bool
    False ([Char]
    y [Char] -> [Char] -> Bool
    forall a. Eq a => a -> a -> Bool
    /=) Maybe [Char]
    mx
          [Char]
    -> Nat
    -> TCMT IO Doc
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.args" Nat
    30 (TCMT IO Doc
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO Doc
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "calling implicitNamedArgs"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "t0 = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t0
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "hx = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Hiding -> [Char]
    forall a. Show a => a -> [Char]
    show Hiding
    hx)
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "mx = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    -> ([Char] -> TCMT IO Doc) -> Maybe [Char] -> TCMT IO Doc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe TCMT IO Doc
    "nothing" [Char] -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Maybe [Char]
    mx
            ]
          (NamedArgs
    nargs, Type
    t) <- TCM (NamedArgs, Type)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr]) (TCMT IO) (NamedArgs, Type)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (NamedArgs, Type)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr]) (TCMT IO) (NamedArgs, Type))
    -> TCM (NamedArgs, Type)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr]) (TCMT IO) (NamedArgs, Type)
    forall a b. (a -> b) -> a -> b
    $ Nat -> (Hiding -> [Char] -> Bool) -> Type -> TCM (NamedArgs, Type)
    forall (m :: * -> *).
    (PureTCM m, MonadMetaSolver m, MonadTCM m) =>
    Nat -> (Hiding -> [Char] -> Bool) -> Type -> m (NamedArgs, Type)
    implicitNamedArgs (-Nat
    1) Hiding -> [Char] -> Bool
    expand Type
    t0
          -- Separate names from args.
          let ([Maybe NamedName]
    mxs, Elims
    us) = [(Maybe NamedName, Elim)] -> ([Maybe NamedName], Elims)
    forall a b. [(a, b)] -> ([a], [b])
    unzip ([(Maybe NamedName, Elim)] -> ([Maybe NamedName], Elims))
    -> [(Maybe NamedName, Elim)] -> ([Maybe NamedName], Elims)
    forall a b. (a -> b) -> a -> b
    $ (Arg (Named NamedName Term) -> (Maybe NamedName, Elim))
    -> NamedArgs -> [(Maybe NamedName, Elim)]
    forall a b. (a -> b) -> [a] -> [b]
    map (\ (Arg ArgInfo
    ai (Named Maybe NamedName
    mx Term
    u)) -> (Maybe NamedName
    mx, Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Arg Term -> Elim) -> Arg Term -> Elim
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    ai Term
    u)) NamedArgs
    nargs
              xs :: [NamedName]
    xs        = [Maybe NamedName] -> [NamedName]
    forall a. [Maybe a] -> [a]
    catMaybes [Maybe NamedName]
    mxs

          -- We need a function type here, but we don't know which kind
          -- (implicit/explicit). But it might be possible to use injectivity to
          -- force a pi.
          Type
    t <- TCMT IO Type
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Type
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO Type
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Type)
    -> TCMT IO Type
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ Type -> TCMT IO Type
    forcePiUsingInjectivity Type
    t

          -- We are done inserting implicit args.  Now, try to check @arg@.
          Type
    -> (Blocker
        -> Type
        -> ExceptT
             (ArgsCheckState [NamedArg Expr])
             (TCMT IO)
             (ArgsCheckState CheckedTarget))
    -> (NotBlocked
        -> Type
        -> ExceptT
             (ArgsCheckState [NamedArg Expr])
             (TCMT IO)
             (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall t (m :: * -> *) a.
    (Reduce t, IsMeta t, MonadReduce m) =>
    t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a
    ifBlocked Type
    t (\ Blocker
    m Type
    t -> ArgsCheckState [NamedArg Expr]
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (ArgsCheckState [NamedArg Expr]
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ArgsCheckState [NamedArg Expr]
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> [NamedArg Expr]
    -> ArgsCheckState [NamedArg Expr]
    forall a.
    MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> a
    -> ArgsCheckState a
    ACState (Nat -> Maybe Range -> MaybeRanges
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe Range
    forall a. Maybe a
    Nothing) Elims
    us (Nat -> Maybe (Abs Constraint) -> [Maybe (Abs Constraint)]
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing) Type
    t [NamedArg Expr]
    args0) ((NotBlocked
      -> Type
      -> ExceptT
           (ArgsCheckState [NamedArg Expr])
           (TCMT IO)
           (ArgsCheckState CheckedTarget))
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> (NotBlocked
        -> Type
        -> ExceptT
             (ArgsCheckState [NamedArg Expr])
             (TCMT IO)
             (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ \ NotBlocked
    _ Type
    t0' -> do

            -- What can go wrong?

            -- 1. We ran out of function types.
            let shouldBePi :: ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    shouldBePi
                  -- a) It is an explicit argument, but we ran out of function types.
                  | ArgInfo -> Bool
    forall a. LensHiding a => a -> Bool
    visible ArgInfo
    info = TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (ArgsCheckState CheckedTarget))
    -> TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ Type -> TypeError
    ShouldBePi Type
    t0'
                  -- b) It is an implicit argument, and we did not insert any implicits.
                  --    Thus, the type was not a function type to start with.
                  | [NamedName] -> Bool
    forall a. Null a => a -> Bool
    null [NamedName]
    xs        = TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (ArgsCheckState CheckedTarget))
    -> TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ Type -> TypeError
    ShouldBePi Type
    t0'
                  -- c) We did insert implicits, but we ran out of implicit function types.
                  --    Then, we should inform the user that we did not find his one.
                  | Bool
    otherwise      = TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (ArgsCheckState CheckedTarget))
    -> TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ NamedArg Expr -> [NamedName] -> TypeError
    WrongNamedArgument NamedArg Expr
    arg [NamedName]
    xs

            -- 2. We have a function type left, but it is the wrong one.
            --    Our argument must be implicit, case a) is impossible.
            --    (Otherwise we would have ran out of function types instead.)
            let wrongPi :: ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    wrongPi
                  -- b) We have not inserted any implicits.
                  | [NamedName] -> Bool
    forall a. Null a => a -> Bool
    null [NamedName]
    xs   = TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (ArgsCheckState CheckedTarget))
    -> TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ Type -> TypeError
    WrongHidingInApplication Type
    t0'
                  -- c) We inserted implicits, but did not find his one.
                  | Bool
    otherwise = TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> TCM (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (ArgsCheckState CheckedTarget))
    -> TypeError -> TCM (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ NamedArg Expr -> [NamedName] -> TypeError
    WrongNamedArgument NamedArg Expr
    arg [NamedName]
    xs

            Type -> PathView
    viewPath <- TCMT IO (Type -> PathView)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr]) (TCMT IO) (Type -> PathView)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift TCMT IO (Type -> PathView)
    forall (m :: * -> *). HasBuiltins m => m (Type -> PathView)
    pathView'

            -- Check the target type if we can get away with it.
            CheckedTarget
    chk' <- TCMT IO CheckedTarget
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) CheckedTarget
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO CheckedTarget
     -> ExceptT
          (ArgsCheckState [NamedArg Expr]) (TCMT IO) CheckedTarget)
    -> TCMT IO CheckedTarget
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) CheckedTarget
    forall a b. (a -> b) -> a -> b
    $
              case (CheckedTarget
    chk, Maybe Type
    mt1) of
                (CheckedTarget
    NotCheckedTarget, Just Type
    t1) | (NamedArg Expr -> Bool) -> [NamedArg Expr] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all NamedArg Expr -> Bool
    forall a. LensHiding a => a -> Bool
    visible [NamedArg Expr]
    args0 -> do
                  let n :: Nat
    n = [NamedArg Expr] -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length [NamedArg Expr]
    args0
                  TelV Tele (Dom Type)
    tel Type
    tgt <- Nat -> Type -> TCMT IO (TelV Type)
    forall (m :: * -> *).
    (MonadReduce m, MonadAddContext m) =>
    Nat -> Type -> m (TelV Type)
    telViewUpTo Nat
    n Type
    t0'
                  let dep :: Bool
    dep = (Nat -> Bool) -> [Nat] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Nat -> Nat -> Bool
    forall a. Ord a => a -> a -> Bool
    < Nat
    n) ([Nat] -> Bool) -> [Nat] -> Bool
    forall a b. (a -> b) -> a -> b
    $ IntSet -> [Nat]
    IntSet.toList (IntSet -> [Nat]) -> IntSet -> [Nat]
    forall a b. (a -> b) -> a -> b
    $ Type -> IntSet
    forall a c t. (IsVarSet a c, Singleton Nat c, Free t) => t -> c
    freeVars Type
    tgt
                      vis :: Bool
    vis = (Dom ([Char], Type) -> Bool) -> [Dom ([Char], Type)] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Dom ([Char], Type) -> Bool
    forall a. LensHiding a => a -> Bool
    visible (Tele (Dom Type) -> [Dom ([Char], Type)]
    forall t. Tele (Dom t) -> [Dom ([Char], t)]
    telToList Tele (Dom Type)
    tel)
                      isRigid :: Type -> TCMT IO Bool
    isRigid Type
    t | PathType{} <- Type -> PathView
    viewPath Type
    t = Bool -> TCMT IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False -- Path is not rigid!
                      isRigid (El Sort' Term
    _ (Pi Dom Type
    dom Abs Type
    _)) = Bool -> TCMT IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Bool -> TCMT IO Bool) -> Bool -> TCMT IO Bool
    forall a b. (a -> b) -> a -> b
    $ Dom Type -> Bool
    forall a. LensHiding a => a -> Bool
    visible Dom Type
    dom
                      isRigid (El Sort' Term
    _ (Def QName
    d Elims
    _))  = QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    d TCMT IO Definition -> (Definition -> Defn) -> TCMT IO Defn
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> Definition -> Defn
    theDef TCMT IO Defn -> (Defn -> Bool) -> TCMT IO Bool
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \ case
                        Axiom{}                   -> Bool
    True
                        DataOrRecSig{}            -> Bool
    True
                        AbstractDefn{}            -> Bool
    True
                        Function{funClauses :: Defn -> [Clause]
    funClauses = [Clause]
    cs} -> [Clause] -> Bool
    forall a. Null a => a -> Bool
    null [Clause]
    cs
                        Datatype{}                -> Bool
    True
                        Record{}                  -> Bool
    True
                        Constructor{}             -> Bool
    forall a. HasCallStack => a
    __IMPOSSIBLE__
                        GeneralizableVar{}        -> Bool
    forall a. HasCallStack => a
    __IMPOSSIBLE__
                        Primitive{}               -> Bool
    False
                        PrimitiveSort{}           -> Bool
    False
                      isRigid Type
    _           = Bool -> TCMT IO Bool
    forall (m :: * -> *) a. Monad m => a -> m a
    return Bool
    False
                  Bool
    rigid <- Type -> TCMT IO Bool
    isRigid Type
    tgt
                  -- Andreas, 2019-03-28, issue #3248:
                  -- If the target type is SIZELT, we need coerce, leqType is insufficient.
                  -- For example, we have i : Size <= (Size< ↑ i), but not Size <= (Size< ↑ i).
                  Bool
    isSizeLt <- Type -> TCMT IO Type
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce Type
    t1 TCMT IO Type
    -> (Type -> TCMT IO (Maybe BoundedSize))
    -> TCMT IO (Maybe BoundedSize)
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= Type -> TCMT IO (Maybe BoundedSize)
    forall a (m :: * -> *).
    (IsSizeType a, HasOptions m, HasBuiltins m) =>
    a -> m (Maybe BoundedSize)
    isSizeType TCMT IO (Maybe BoundedSize)
    -> (Maybe BoundedSize -> Bool) -> TCMT IO Bool
    forall (m :: * -> *) a b. Functor m => m a -> (a -> b) -> m b
    <&> \case
                    Just (BoundedLt Term
    _) -> Bool
    True
                    Maybe BoundedSize
    _ -> Bool
    False
                  if | Bool
    dep       -> CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. Monad m => a -> m a
    return CheckedTarget
    chk    -- must be non-dependent
                     | Bool -> Bool
    not Bool
    rigid -> CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. Monad m => a -> m a
    return CheckedTarget
    chk    -- with a rigid target
                     | Bool -> Bool
    not Bool
    vis   -> CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. Monad m => a -> m a
    return CheckedTarget
    chk    -- and only visible arguments
                     | Bool
    isSizeLt  -> CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. Monad m => a -> m a
    return CheckedTarget
    chk    -- Issue #3248, not Size<
                     | Bool
    otherwise -> do
                      let tgt1 :: Type
    tgt1 = Substitution' (SubstArg Type) -> Type -> Type
    forall a. Subst a => Substitution' (SubstArg a) -> a -> a
    applySubst (Impossible -> Nat -> Substitution' Term
    forall a. Impossible -> Nat -> Substitution' a
    strengthenS Impossible
    HasCallStack => Impossible
    impossible (Nat -> Substitution' Term) -> Nat -> Substitution' Term
    forall a b. (a -> b) -> a -> b
    $ Tele (Dom Type) -> Nat
    forall a. Sized a => a -> Nat
    size Tele (Dom Type)
    tel) Type
    tgt
                      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.args.target" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                        [ TCMT IO Doc
    "Checking target types first"
                        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "inferred =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    tgt1
                        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "expected =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t1 ]
                      Call -> TCMT IO CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. MonadTrace m => Call -> m a -> m a
    traceCall (Range -> Type -> Type -> Call
    CheckTargetType (Range -> [NamedArg Expr] -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Range
    r [NamedArg Expr]
    args0) Type
    tgt1 Type
    t1) (TCMT IO CheckedTarget -> TCMT IO CheckedTarget)
    -> TCMT IO CheckedTarget -> TCMT IO CheckedTarget
    forall a b. (a -> b) -> a -> b
    $
                        Maybe ProblemId -> CheckedTarget
    CheckedTarget (Maybe ProblemId -> CheckedTarget)
    -> TCMT IO (Maybe ProblemId) -> TCMT IO CheckedTarget
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO ()
    -> TCMT IO (Maybe ProblemId)
    -> (ProblemId -> TCMT IO (Maybe ProblemId))
    -> TCMT IO (Maybe ProblemId)
    forall a. TCMT IO () -> TCM a -> (ProblemId -> TCM a) -> TCM a
    ifNoConstraints_ (Comparison -> Type -> Type -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Comparison -> Type -> Type -> m ()
    compareType Comparison
    cmp Type
    tgt1 Type
    t1)
                                            (Maybe ProblemId -> TCMT IO (Maybe ProblemId)
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe ProblemId
    forall a. Maybe a
    Nothing) (Maybe ProblemId -> TCMT IO (Maybe ProblemId)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Maybe ProblemId -> TCMT IO (Maybe ProblemId))
    -> (ProblemId -> Maybe ProblemId)
    -> ProblemId
    -> TCMT IO (Maybe ProblemId)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ProblemId -> Maybe ProblemId
    forall a. a -> Maybe a
    Just)

                (CheckedTarget, Maybe Type)
    _ -> CheckedTarget -> TCMT IO CheckedTarget
    forall (m :: * -> *) a. Monad m => a -> m a
    return CheckedTarget
    chk

            -- t0' <- lift $ forcePi (getHiding info) (maybe "_" rangedThing $ nameOf e) t0'
            case Type -> Term
    forall t a. Type'' t a -> a
    unEl Type
    t0' of
              Pi (Dom{domInfo :: forall t e. Dom' t e -> ArgInfo
    domInfo = ArgInfo
    info', domName :: forall t e. Dom' t e -> Maybe NamedName
    domName = Maybe NamedName
    dname, unDom :: forall t e. Dom' t e -> e
    unDom = Type
    a}) Abs Type
    b
                | let name :: [Char]
    name = [Char] -> Maybe NamedName -> [Char]
    forall a.
    (LensNamed a, NameOf a ~ NamedName) =>
    [Char] -> a -> [Char]
    bareNameWithDefault [Char]
    "_" Maybe NamedName
    dname,
                  ArgInfo -> ArgInfo -> Bool
    forall a b. (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding ArgInfo
    info ArgInfo
    info'
                  Bool -> Bool -> Bool
    && (ArgInfo -> Bool
    forall a. LensHiding a => a -> Bool
    visible ArgInfo
    info Bool -> Bool -> Bool
    || Bool -> ([Char] -> Bool) -> Maybe [Char] -> Bool
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Bool
    True ([Char]
    name [Char] -> [Char] -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) Maybe [Char]
    mx) -> do
                    Term
    u <- TCM Term -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM Term
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term)
    -> TCM Term
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> TCM Term -> TCM Term
    forall (tcm :: * -> *) m a.
    (MonadTCEnv tcm, LensModality m) =>
    m -> tcm a -> tcm a
    applyModalityToContext ArgInfo
    info' (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
                     -- Andreas, 2014-05-30 experiment to check non-dependent arguments
                     -- after the spine has been processed.  Allows to propagate type info
                     -- from ascribed type into extended-lambdas.  Would solve issue 1159.
                     -- However, leaves unsolved type checking problems in the test suite.
                     -- I do not know what I am doing wrong here.
                     -- Could be extreme order-sensitivity or my abuse of the postponing
                     -- mechanism.
                     -- Andreas, 2016-02-02: Ulf says unless there is actually some meta
                     -- blocking a postponed type checking problem, we might never retry,
                     -- since the trigger for retrying constraints is solving a meta.
                     -- Thus, the following naive use violates some invariant.
                     -- if not $ isBinderUsed b
                     -- then postponeTypeCheckingProblem (CheckExpr (namedThing e) a) (return True) else
                      let e' :: Named_ Expr
    e' = Named_ Expr
    e { nameOf :: Maybe NamedName
    nameOf = (Named_ Expr -> Maybe NamedName
    forall name a. Named name a -> Maybe name
    nameOf Named_ Expr
    e) Maybe NamedName -> Maybe NamedName -> Maybe NamedName
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Maybe NamedName
    dname }
                      NamedArg Expr -> Type -> TCM Term
    checkNamedArg (ArgInfo -> Named_ Expr -> NamedArg Expr
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    info' Named_ Expr
    e') Type
    a

                    let c :: Maybe (Abs Constraint)
    c | Lock
    IsLock Lock -> Lock -> Bool
    forall a. Eq a => a -> a -> Bool
    == ArgInfo -> Lock
    forall a. LensLock a => a -> Lock
    getLock ArgInfo
    info' = Abs Constraint -> Maybe (Abs Constraint)
    forall a. a -> Maybe a
    Just (Abs Constraint -> Maybe (Abs Constraint))
    -> Abs Constraint -> Maybe (Abs Constraint)
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Constraint -> Abs Constraint
    forall a. [Char] -> a -> Abs a
    Abs [Char]
    "t" (Term -> Type -> Arg Term -> Type -> Constraint
    CheckLockedVars (Nat -> Elims -> Term
    Var Nat
    0 []) (Nat -> Type -> Type
    forall a. Subst a => Nat -> a -> a
    raise Nat
    1 Type
    t0') (Nat -> Arg Term -> Arg Term
    forall a. Subst a => Nat -> a -> a
    raise Nat
    1 (Arg Term -> Arg Term) -> Arg Term -> Arg Term
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    info' Term
    u) (Nat -> Type -> Type
    forall a. Subst a => Nat -> a -> a
    raise Nat
    1 Type
    a))
                          | Bool
    otherwise = Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing
                    TCMT IO () -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO ()
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO ()
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.lock" Nat
    40 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    "lock =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Lock -> [Char]
    forall a. Show a => a -> [Char]
    show (Lock -> [Char]) -> Lock -> [Char]
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Lock
    forall a. LensLock a => a -> Lock
    getLock ArgInfo
    info')
                    TCMT IO () -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO ()
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO ()
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.lock" Nat
    40 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Dom Type -> TCMT IO Doc -> TCMT IO Doc
    forall b (m :: * -> *) a.
    (AddContext b, MonadAddContext m) =>
    b -> m a -> m a
    addContext (Type -> Dom Type
    forall a. a -> Dom a
    defaultDom (Type -> Dom Type) -> Type -> Dom Type
    forall a b. (a -> b) -> a -> b
    $ Type
    t0') (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    -> (Constraint -> TCMT IO Doc) -> Maybe Constraint -> TCMT IO Doc
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ([Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    "nothing") Constraint -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM (Abs Constraint -> Constraint
    forall a. Subst a => Abs a -> a
    absBody (Abs Constraint -> Constraint)
    -> Maybe (Abs Constraint) -> Maybe Constraint
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Abs Constraint)
    c)
                    -- save relevance info' from domain in argument
                    Elims
    -> Range
    -> Elim
    -> Maybe (Abs Constraint)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall {a} {m :: * -> *} {a}.
    MonadError (ArgsCheckState a) m =>
    Elims
    -> Range
    -> Elim
    -> Maybe (Abs Constraint)
    -> m (ArgsCheckState a)
    -> m (ArgsCheckState a)
    addCheckedArgs Elims
    us (Named_ Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Named_ Expr
    e) (Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Arg Term -> Elim) -> Arg Term -> Elim
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    info' Term
    u) Maybe (Abs Constraint)
    c (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $
                      CheckedTarget
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE' CheckedTarget
    chk' Comparison
    cmp ExpandHidden
    exh (Range -> Named_ Expr -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Range
    r Named_ Expr
    e) [NamedArg Expr]
    args (Abs Type -> SubstArg Type -> Type
    forall a. Subst a => Abs a -> SubstArg a -> a
    absApp Abs Type
    b Term
    SubstArg Type
    u) Maybe Type
    mt1
                | Bool
    otherwise -> do
                    [Char]
    -> Nat
    -> TCMT IO Doc
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "error" Nat
    10 (TCMT IO Doc
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO Doc
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                      [ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "info      = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ ArgInfo -> [Char]
    forall a. Show a => a -> [Char]
    show ArgInfo
    info
                      , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "info'     = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ ArgInfo -> [Char]
    forall a. Show a => a -> [Char]
    show ArgInfo
    info'
                      , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "absName b = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Abs Type -> [Char]
    forall a. Abs a -> [Char]
    absName Abs Type
    b
                      , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "nameOf e  = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Maybe NamedName -> [Char]
    forall a. Show a => a -> [Char]
    show (Named_ Expr -> Maybe NamedName
    forall name a. Named name a -> Maybe name
    nameOf Named_ Expr
    e)
                      ]
                    ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    wrongPi
              Term
    _
                | ArgInfo -> Bool
    forall a. LensHiding a => a -> Bool
    visible ArgInfo
    info
                , PathType Sort' Term
    s QName
    _ Arg Term
    _ Arg Term
    bA Arg Term
    x Arg Term
    y <- Type -> PathView
    viewPath Type
    t0' -> do
                    TCMT IO () -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO ()
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ())
    -> TCMT IO ()
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.args" Nat
    30 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> [Char]
    forall a. Show a => a -> [Char]
    show Arg Term
    bA
                    Term
    u <- TCM Term -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM Term
     -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term)
    -> TCM Term
    -> ExceptT (ArgsCheckState [NamedArg Expr]) (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ Expr -> Type -> TCM Term
    checkExpr (Named_ Expr -> Expr
    forall name a. Named name a -> a
    namedThing Named_ Expr
    e) (Type -> TCM Term) -> TCMT IO Type -> TCM Term
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< TCMT IO Type
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Type
    primIntervalType
                    Elims
    -> Range
    -> Elim
    -> Maybe (Abs Constraint)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall {a} {m :: * -> *} {a}.
    MonadError (ArgsCheckState a) m =>
    Elims
    -> Range
    -> Elim
    -> Maybe (Abs Constraint)
    -> m (ArgsCheckState a)
    -> m (ArgsCheckState a)
    addCheckedArgs Elims
    us (Named_ Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Named_ Expr
    e) (Term -> Term -> Term -> Elim
    forall a. a -> a -> a -> Elim' a
    IApply (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    x) (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    y) Term
    u) Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> ExceptT
          (ArgsCheckState [NamedArg Expr])
          (TCMT IO)
          (ArgsCheckState CheckedTarget))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $
                      Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE Comparison
    cmp ExpandHidden
    exh (Range -> Named_ Expr -> Range
    forall u t. (HasRange u, HasRange t) => u -> t -> Range
    fuseRange Range
    r Named_ Expr
    e) [NamedArg Expr]
    args (Sort' Term -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El Sort' Term
    s (Term -> Type) -> Term -> Type
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    bA Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Term -> Arg Term
    forall e. e -> Arg e
    argN Term
    u]) Maybe Type
    mt1
              Term
    _ -> ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    shouldBePi
      where
        -- Andrea: Here one would add constraints too.
        addCheckedArgs :: Elims
    -> Range
    -> Elim
    -> Maybe (Abs Constraint)
    -> m (ArgsCheckState a)
    -> m (ArgsCheckState a)
    addCheckedArgs Elims
    us Range
    r Elim
    u Maybe (Abs Constraint)
    c m (ArgsCheckState a)
    rec = do
            st :: ArgsCheckState a
    st@ACState{acRanges :: forall a. ArgsCheckState a -> MaybeRanges
    acRanges = MaybeRanges
    rs, acElims :: forall a. ArgsCheckState a -> Elims
    acElims = Elims
    vs} <- m (ArgsCheckState a)
    rec
            let rs' :: MaybeRanges
    rs' = Nat -> Maybe Range -> MaybeRanges
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe Range
    forall a. Maybe a
    Nothing MaybeRanges -> MaybeRanges -> MaybeRanges
    forall a. [a] -> [a] -> [a]
    ++ Range -> Maybe Range
    forall a. a -> Maybe a
    Just Range
    r Maybe Range -> MaybeRanges -> MaybeRanges
    forall a. a -> [a] -> [a]
    : MaybeRanges
    rs
                cs' :: [Maybe (Abs Constraint)]
    cs' = Nat -> Maybe (Abs Constraint) -> [Maybe (Abs Constraint)]
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing [Maybe (Abs Constraint)]
    -> [Maybe (Abs Constraint)] -> [Maybe (Abs Constraint)]
    forall a. [a] -> [a] -> [a]
    ++ Maybe (Abs Constraint)
    c Maybe (Abs Constraint)
    -> [Maybe (Abs Constraint)] -> [Maybe (Abs Constraint)]
    forall a. a -> [a] -> [a]
    : ArgsCheckState a -> [Maybe (Abs Constraint)]
    forall a. ArgsCheckState a -> [Maybe (Abs Constraint)]
    acConstraints ArgsCheckState a
    st
            ArgsCheckState a -> m (ArgsCheckState a)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ArgsCheckState a -> m (ArgsCheckState a))
    -> ArgsCheckState a -> m (ArgsCheckState a)
    forall a b. (a -> b) -> a -> b
    $ ArgsCheckState a
    st { acRanges :: MaybeRanges
    acRanges = MaybeRanges
    rs', acElims :: Elims
    acElims = Elims
    us Elims -> Elims -> Elims
    forall a. [a] -> [a] -> [a]
    ++ Elim
    u Elim -> Elims -> Elims
    forall a. a -> [a] -> [a]
    : Elims
    vs, acConstraints :: [Maybe (Abs Constraint)]
    acConstraints = [Maybe (Abs Constraint)]
    cs' }
          m (ArgsCheckState a)
    -> (ArgsCheckState a -> m (ArgsCheckState a))
    -> m (ArgsCheckState a)
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    `catchError` \ st :: ArgsCheckState a
    st@ACState{acRanges :: forall a. ArgsCheckState a -> MaybeRanges
    acRanges = MaybeRanges
    rs, acElims :: forall a. ArgsCheckState a -> Elims
    acElims = Elims
    vs} -> do
              let rs' :: MaybeRanges
    rs' = Nat -> Maybe Range -> MaybeRanges
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe Range
    forall a. Maybe a
    Nothing MaybeRanges -> MaybeRanges -> MaybeRanges
    forall a. [a] -> [a] -> [a]
    ++ Range -> Maybe Range
    forall a. a -> Maybe a
    Just Range
    r Maybe Range -> MaybeRanges -> MaybeRanges
    forall a. a -> [a] -> [a]
    : MaybeRanges
    rs
                  cs' :: [Maybe (Abs Constraint)]
    cs' = Nat -> Maybe (Abs Constraint) -> [Maybe (Abs Constraint)]
    forall a. Nat -> a -> [a]
    replicate (Elims -> Nat
    forall (t :: * -> *) a. Foldable t => t a -> Nat
    length Elims
    us) Maybe (Abs Constraint)
    forall a. Maybe a
    Nothing [Maybe (Abs Constraint)]
    -> [Maybe (Abs Constraint)] -> [Maybe (Abs Constraint)]
    forall a. [a] -> [a] -> [a]
    ++ Maybe (Abs Constraint)
    c Maybe (Abs Constraint)
    -> [Maybe (Abs Constraint)] -> [Maybe (Abs Constraint)]
    forall a. a -> [a] -> [a]
    : ArgsCheckState a -> [Maybe (Abs Constraint)]
    forall a. ArgsCheckState a -> [Maybe (Abs Constraint)]
    acConstraints ArgsCheckState a
    st
              ArgsCheckState a -> m (ArgsCheckState a)
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError (ArgsCheckState a -> m (ArgsCheckState a))
    -> ArgsCheckState a -> m (ArgsCheckState a)
    forall a b. (a -> b) -> a -> b
    $ ArgsCheckState a
    st { acRanges :: MaybeRanges
    acRanges = MaybeRanges
    rs', acElims :: Elims
    acElims = Elims
    us Elims -> Elims -> Elims
    forall a. [a] -> [a] -> [a]
    ++ Elim
    u Elim -> Elims -> Elims
    forall a. a -> [a] -> [a]
    : Elims
    vs, acConstraints :: [Maybe (Abs Constraint)]
    acConstraints = [Maybe (Abs Constraint)]
    cs' }

    -- | Check that a list of arguments fits a telescope.
    --   Inserts hidden arguments as necessary.
    --   Returns the type-checked arguments and the remaining telescope.
    checkArguments_
      :: Comparison           -- ^ Comparison for target
      -> ExpandHidden         -- ^ Eagerly insert trailing hidden arguments?
      -> Range                -- ^ Range of application.
      -> [NamedArg A.Expr]    -- ^ Arguments to check.
      -> Telescope            -- ^ Telescope to check arguments against.
      -> TCM (Elims, Telescope)
         -- ^ Checked arguments and remaining telescope if successful.
    checkArguments_ :: Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Tele (Dom Type)
    -> TCMT IO (Elims, Tele (Dom Type))
    checkArguments_ Comparison
    cmp ExpandHidden
    exh Range
    r [NamedArg Expr]
    args Tele (Dom Type)
    tel = TCMT IO (Elims, Tele (Dom Type))
    -> TCMT IO (Elims, Tele (Dom Type))
    forall a. TCM a -> TCM a
    postponeInstanceConstraints (TCMT IO (Elims, Tele (Dom Type))
     -> TCMT IO (Elims, Tele (Dom Type)))
    -> TCMT IO (Elims, Tele (Dom Type))
    -> TCMT IO (Elims, Tele (Dom Type))
    forall a b. (a -> b) -> a -> b
    $ do
        Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z <- ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> TCM
          (Either
             (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall a b. (a -> b) -> a -> b
    $
          Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE Comparison
    cmp ExpandHidden
    exh Range
    r [NamedArg Expr]
    args (Tele (Dom Type) -> Type -> Type
    telePi Tele (Dom Type)
    tel Type
    HasCallStack => Type
    __DUMMY_TYPE__) Maybe Type
    forall a. Maybe a
    Nothing
        case Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z of
          Right (ACState MaybeRanges
    _ Elims
    args [Maybe (Abs Constraint)]
    cs Type
    t CheckedTarget
    _) | (Maybe (Abs Constraint) -> Bool)
    -> [Maybe (Abs Constraint)] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    all Maybe (Abs Constraint) -> Bool
    forall a. Maybe a -> Bool
    isNothing [Maybe (Abs Constraint)]
    cs -> do
            let TelV Tele (Dom Type)
    tel' Type
    _ = Type -> TelV Type
    telView' Type
    t
            (Elims, Tele (Dom Type)) -> TCMT IO (Elims, Tele (Dom Type))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Elims
    args, Tele (Dom Type)
    tel')
                                        | Bool
    otherwise -> do
            TypeError -> TCMT IO (Elims, Tele (Dom Type))
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO (Elims, Tele (Dom Type)))
    -> TypeError -> TCMT IO (Elims, Tele (Dom Type))
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    GenericError ([Char] -> TypeError) -> [Char] -> TypeError
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "Head constraints are not (yet) supported in this position."
          Left ArgsCheckState [NamedArg Expr]
    _ -> TCMT IO (Elims, Tele (Dom Type))
    forall a. HasCallStack => a
    __IMPOSSIBLE__  -- type cannot be blocked as it is generated by telePi

    -- | @checkArguments cmp exph r args t0 t k@ tries @checkArgumentsE exph args t0 t@.
    -- If it succeeds, it continues @k@ with the returned results.  If it fails,
    -- it registers a postponed typechecking problem and returns the resulting new
    -- meta variable.
    --
    -- Checks @e := ((_ : t0) args) : t@.
    checkArguments ::
      Comparison -> ExpandHidden -> Range -> [NamedArg A.Expr] -> Type -> Type ->
      (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    checkArguments :: Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    checkArguments Comparison
    cmp ExpandHidden
    exph Range
    r [NamedArg Expr]
    args Type
    t0 Type
    t ArgsCheckState CheckedTarget -> TCM Term
    k = TCM Term -> TCM Term
    forall a. TCM a -> TCM a
    postponeInstanceConstraints (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
      Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z <- ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> TCM
          (Either
             (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall a b. (a -> b) -> a -> b
    $ Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE Comparison
    cmp ExpandHidden
    exph Range
    r [NamedArg Expr]
    args Type
    t0 (Type -> Maybe Type
    forall a. a -> Maybe a
    Just Type
    t)
      case Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z of
        Right ArgsCheckState CheckedTarget
    st -> ArgsCheckState CheckedTarget -> TCM Term
    k ArgsCheckState CheckedTarget
    st
          -- vs = evaluated args
          -- t1 = remaining type (needs to be subtype of t)
        Left ArgsCheckState [NamedArg Expr]
    problem -> ArgsCheckState [NamedArg Expr]
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    postponeArgs ArgsCheckState [NamedArg Expr]
    problem Comparison
    cmp ExpandHidden
    exph Range
    r [NamedArg Expr]
    args Type
    t ArgsCheckState CheckedTarget -> TCM Term
    k
          -- if unsuccessful, postpone checking until t0 unblocks

    postponeArgs :: (ArgsCheckState [NamedArg A.Expr]) -> Comparison -> ExpandHidden -> Range -> [NamedArg A.Expr] -> Type ->
                    (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    postponeArgs :: ArgsCheckState [NamedArg Expr]
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    postponeArgs (ACState MaybeRanges
    rs Elims
    us [Maybe (Abs Constraint)]
    cs Type
    t0 [NamedArg Expr]
    es) Comparison
    cmp ExpandHidden
    exph Range
    r [NamedArg Expr]
    args Type
    t ArgsCheckState CheckedTarget -> TCM Term
    k = do
      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.expr.args" Nat
    80 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
        [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep [ TCMT IO Doc
    "postponed checking arguments"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    4 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Semigroup (m Doc), Foldable t) =>
    t (m Doc) -> m Doc
    prettyList ((NamedArg Expr -> TCMT IO Doc) -> [NamedArg Expr] -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map (Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA (Expr -> TCMT IO Doc)
    -> (NamedArg Expr -> Expr) -> NamedArg Expr -> TCMT IO Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Named_ Expr -> Expr
    forall name a. Named name a -> a
    namedThing (Named_ Expr -> Expr)
    -> (NamedArg Expr -> Named_ Expr) -> NamedArg Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedArg Expr -> Named_ Expr
    forall e. Arg e -> e
    unArg) [NamedArg Expr]
    args)
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "against"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    4 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t0 ] TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    $$
        [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep [ TCMT IO Doc
    "progress:"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "checked" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Semigroup (m Doc), Foldable t) =>
    t (m Doc) -> m Doc
    prettyList ((Elim -> TCMT IO Doc) -> Elims -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map Elim -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Elims
    us)
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "remaining" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep [ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Semigroup (m Doc), Foldable t) =>
    t (m Doc) -> m Doc
    prettyList ((NamedArg Expr -> TCMT IO Doc) -> [NamedArg Expr] -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map (Expr -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA (Expr -> TCMT IO Doc)
    -> (NamedArg Expr -> Expr) -> NamedArg Expr -> TCMT IO Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Named_ Expr -> Expr
    forall name a. Named name a -> a
    namedThing (Named_ Expr -> Expr)
    -> (NamedArg Expr -> Named_ Expr) -> NamedArg Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedArg Expr -> Named_ Expr
    forall e. Arg e -> e
    unArg) [NamedArg Expr]
    es)
                                                , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    ":" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t0 ] ]
      TypeCheckingProblem -> TCM Term
    postponeTypeCheckingProblem_ (Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TypeCheckingProblem
    CheckArgs Comparison
    cmp ExpandHidden
    exph Range
    r [NamedArg Expr]
    es Type
    t0 Type
    t ((ArgsCheckState CheckedTarget -> TCM Term) -> TypeCheckingProblem)
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TypeCheckingProblem
    forall a b. (a -> b) -> a -> b
    $ \ (ACState MaybeRanges
    rs' Elims
    vs [Maybe (Abs Constraint)]
    cs' Type
    t CheckedTarget
    pid) -> ArgsCheckState CheckedTarget -> TCM Term
    k (ArgsCheckState CheckedTarget -> TCM Term)
    -> ArgsCheckState CheckedTarget -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> CheckedTarget
    -> ArgsCheckState CheckedTarget
    forall a.
    MaybeRanges
    -> Elims
    -> [Maybe (Abs Constraint)]
    -> Type
    -> a
    -> ArgsCheckState a
    ACState (MaybeRanges
    rs MaybeRanges -> MaybeRanges -> MaybeRanges
    forall a. [a] -> [a] -> [a]
    ++ MaybeRanges
    rs') (Elims
    us Elims -> Elims -> Elims
    forall a. [a] -> [a] -> [a]
    ++ Elims
    vs) ([Maybe (Abs Constraint)]
    cs [Maybe (Abs Constraint)]
    -> [Maybe (Abs Constraint)] -> [Maybe (Abs Constraint)]
    forall a. [a] -> [a] -> [a]
    ++ [Maybe (Abs Constraint)]
    cs') Type
    t CheckedTarget
    pid)

    -----------------------------------------------------------------------------
    -- * Constructors
    -----------------------------------------------------------------------------

    -- | Check the type of a constructor application. This is easier than
    --   a general application since the implicit arguments can be inserted
    --   without looking at the arguments to the constructor.
    checkConstructorApplication :: Comparison -> A.Expr -> Type -> ConHead -> [NamedArg A.Expr] -> TCM Term
    checkConstructorApplication :: Comparison
    -> Expr -> Type -> ConHead -> [NamedArg Expr] -> TCM Term
    checkConstructorApplication Comparison
    cmp Expr
    org Type
    t ConHead
    c [NamedArg Expr]
    args = do
      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
        [ TCMT IO Doc
    "entering checkConstructorApplication"
        , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
          [ TCMT IO Doc
    "org  =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Expr -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Expr
    org
          , TCMT IO Doc
    "t    =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t
          , TCMT IO Doc
    "c    =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> ConHead -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM ConHead
    c
          , TCMT IO Doc
    "args =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [NamedArg Expr] -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM [NamedArg Expr]
    args
        ] ]

      Definition
    cdef  <- ConHead -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => ConHead -> m Definition
    getConInfo ConHead
    c

      QName -> Definition -> TCMT IO ()
    checkModality (ConHead -> QName
    conName ConHead
    c) Definition
    cdef

      let paramsGiven :: Bool
    paramsGiven = [NamedArg Expr] -> Bool
    checkForParams [NamedArg Expr]
    args
      if Bool
    paramsGiven then TCM Term
    fallback else do
        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "checkConstructorApplication: no parameters explicitly supplied, continuing..."

        let Constructor{conData :: Defn -> QName
    conData = QName
    d, conPars :: Defn -> Nat
    conPars = Nat
    npars} = Definition -> Defn
    theDef Definition
    cdef
        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "d    =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    d
        -- Issue 661: t maybe an evaluated form of d .., so we evaluate d
        -- as well and then check wether we deal with the same datatype
        Term
    t0 <- Term -> TCM Term
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce (QName -> Elims -> Term
    Def QName
    d [])
        Type
    tReduced <- Type -> TCMT IO Type
    forall a (m :: * -> *). (Reduce a, MonadReduce m) => a -> m a
    reduce Type
    t
        case (Term
    t0, Type -> Term
    forall t a. Type'' t a -> a
    unEl Type
    tReduced) of -- Only fully applied constructors get special treatment
          (Def QName
    d0 Elims
    _, Def QName
    d' Elims
    es) -> do
            let ~(Just Args
    vs) = Elims -> Maybe Args
    forall a. [Elim' a] -> Maybe [Arg a]
    allApplyElims Elims
    es
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "d0   =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    d0
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "d'   =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    d'
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "vs   =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Args -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Args
    vs
            if QName
    d' QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    /= QName
    d0 then TCM Term
    fallback else do
             -- Issue 661: d' may take more parameters than d, in particular
             -- these additional parameters could be a module parameter telescope.
             -- Since we get the constructor type ctype from d but the parameters
             -- from t = Def d' vs, we drop the additional parameters.
             Maybe Nat
    npars' <- QName -> TCMT IO (Maybe Nat)
    forall (m :: * -> *). HasConstInfo m => QName -> m (Maybe Nat)
    getNumberOfParameters QName
    d'
             Maybe (Pair Nat) -> TCM Term -> (Pair Nat -> TCM Term) -> TCM Term
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe (Pair (Maybe Nat) -> Maybe (Pair Nat)
    forall (t :: * -> *) (f :: * -> *) a.
    (Traversable t, Applicative f) =>
    t (f a) -> f (t a)
    sequenceA (Pair (Maybe Nat) -> Maybe (Pair Nat))
    -> Pair (Maybe Nat) -> Maybe (Pair Nat)
    forall a b. (a -> b) -> a -> b
    $ Maybe Nat -> Maybe Nat -> Pair (Maybe Nat)
    forall a. a -> a -> Pair a
    Pair (Nat -> Maybe Nat
    forall a. a -> Maybe a
    Just Nat
    npars) Maybe Nat
    npars') TCM Term
    fallback ((Pair Nat -> TCM Term) -> TCM Term)
    -> (Pair Nat -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ (Pair Nat
    n Nat
    n') -> do
               [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "n    = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Nat -> [Char]
    forall a. Show a => a -> [Char]
    show Nat
    n
               [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "n'   = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Nat -> [Char]
    forall a. Show a => a -> [Char]
    show Nat
    n'
               Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (Nat
    n Nat -> Nat -> Bool
    forall a. Ord a => a -> a -> Bool
    > Nat
    n')  -- preprocessor does not like ', so put on next line
                 TCMT IO ()
    forall a. HasCallStack => a
    __IMPOSSIBLE__
               let ps :: Args
    ps    = Nat -> Args -> Args
    forall a. Nat -> [a] -> [a]
    take Nat
    n (Args -> Args) -> Args -> Args
    forall a b. (a -> b) -> a -> b
    $ Nat -> Args -> Args
    forall a. Nat -> [a] -> [a]
    drop (Nat
    n' Nat -> Nat -> Nat
    forall a. Num a => a -> a -> a
    - Nat
    n) Args
    vs
                   ctype :: Type
    ctype = Definition -> Type
    defType Definition
    cdef
               [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                 [ TCMT IO Doc
    "special checking of constructor application of" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> ConHead -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM ConHead
    c
                 , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat [ TCMT IO Doc
    "ps     =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Args -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Args
    ps
                                 , TCMT IO Doc
    "ctype  =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    ctype ] ]
               let ctype' :: Type
    ctype' = Type
    ctype Type -> Args -> Type
    `piApply` Args
    ps
               [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "ctype' =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    ctype'
               -- get the parameter names
               let TelV Tele (Dom Type)
    ptel Type
    _ = Nat -> Type -> TelV Type
    telView'UpTo Nat
    n Type
    ctype
               let pnames :: [Dom' Term [Char]]
    pnames = (Dom ([Char], Type) -> Dom' Term [Char])
    -> [Dom ([Char], Type)] -> [Dom' Term [Char]]
    forall a b. (a -> b) -> [a] -> [b]
    map ((([Char], Type) -> [Char])
    -> Dom ([Char], Type) -> Dom' Term [Char]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ([Char], Type) -> [Char]
    forall a b. (a, b) -> a
    fst) ([Dom ([Char], Type)] -> [Dom' Term [Char]])
    -> [Dom ([Char], Type)] -> [Dom' Term [Char]]
    forall a b. (a -> b) -> a -> b
    $ Tele (Dom Type) -> [Dom ([Char], Type)]
    forall t. Tele (Dom t) -> [Dom ([Char], t)]
    telToList Tele (Dom Type)
    ptel
               -- drop the parameter arguments
                   args' :: [NamedArg Expr]
    args' = [Dom' Term [Char]] -> [NamedArg Expr] -> [NamedArg Expr]
    dropArgs [Dom' Term [Char]]
    pnames [NamedArg Expr]
    args
               -- check the non-parameter arguments
               ExpandHidden
    expandLast <- (TCEnv -> ExpandHidden) -> TCMT IO ExpandHidden
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> ExpandHidden
    envExpandLast
               Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    checkArguments Comparison
    cmp ExpandHidden
    expandLast (ConHead -> Range
    forall a. HasRange a => a -> Range
    getRange ConHead
    c) [NamedArg Expr]
    args' Type
    ctype' Type
    t ((ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term)
    -> (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ st :: ArgsCheckState CheckedTarget
    st@(ACState MaybeRanges
    _ Elims
    _ [Maybe (Abs Constraint)]
    _ Type
    t' CheckedTarget
    targetCheck) -> do
                 [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                   [ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    "es     =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Elims -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Elims
    es
                   , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text [Char]
    "t'     =" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t' ]
                 Term
    v <- (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints (ConHead -> ConInfo -> Elims -> Term
    Con ConHead
    c ConInfo
    ConOCon) ArgsCheckState CheckedTarget
    st
                 Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    targetCheck Term
    v Type
    t' Type
    t
          (Term, Term)
    _ -> do
            [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.con" Nat
    50 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ TCMT IO Doc
    "we are not at a datatype, falling back"
            TCM Term
    fallback
      where
        fallback :: TCM Term
    fallback = Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    org Type
    t (AmbiguousQName -> Expr
    A.Con (QName -> AmbiguousQName
    unambiguous (QName -> AmbiguousQName) -> QName -> AmbiguousQName
    forall a b. (a -> b) -> a -> b
    $ ConHead -> QName
    conName ConHead
    c)) [NamedArg Expr]
    args

        -- Check if there are explicitly given hidden arguments,
        -- in which case we fall back to default type checking.
        -- We could work harder, but let's not for now.
        --
        -- Andreas, 2012-04-18: if all inital args are underscores, ignore them
        checkForParams :: [NamedArg Expr] -> Bool
    checkForParams [NamedArg Expr]
    args =
          let ([NamedArg Expr]
    hargs, [NamedArg Expr]
    rest) = (NamedArg Expr -> Bool)
    -> [NamedArg Expr] -> ([NamedArg Expr], [NamedArg Expr])
    forall a. (a -> Bool) -> [a] -> ([a], [a])
    break NamedArg Expr -> Bool
    forall a. LensHiding a => a -> Bool
    visible [NamedArg Expr]
    args
              notUnderscore :: Expr -> Bool
    notUnderscore A.Underscore{} = Bool
    False
              notUnderscore Expr
    _              = Bool
    True
          in  (NamedArg Expr -> Bool) -> [NamedArg Expr] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any (Expr -> Bool
    notUnderscore (Expr -> Bool) -> (NamedArg Expr -> Expr) -> NamedArg Expr -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Expr -> Expr
    unScope (Expr -> Expr) -> (NamedArg Expr -> Expr) -> NamedArg Expr -> Expr
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NamedArg Expr -> Expr
    forall a. NamedArg a -> a
    namedArg) [NamedArg Expr]
    hargs

        -- Drop the constructor arguments that correspond to parameters.
        dropArgs :: [Dom' Term [Char]] -> [NamedArg Expr] -> [NamedArg Expr]
    dropArgs [] [NamedArg Expr]
    args                = [NamedArg Expr]
    args
        dropArgs [Dom' Term [Char]]
    ps []                  = [NamedArg Expr]
    args
        dropArgs [Dom' Term [Char]]
    ps args :: [NamedArg Expr]
    args@(NamedArg Expr
    arg : [NamedArg Expr]
    args')
          | Just [Char]
    p   <- Maybe [Char]
    name,
            Just [Dom' Term [Char]]
    ps' <- [Char] -> [Dom' Term [Char]] -> Maybe [Dom' Term [Char]]
    forall {b} {t}. Eq b => b -> [Dom' t b] -> Maybe [Dom' t b]
    namedPar [Char]
    p [Dom' Term [Char]]
    ps   = [Dom' Term [Char]] -> [NamedArg Expr] -> [NamedArg Expr]
    dropArgs [Dom' Term [Char]]
    ps' [NamedArg Expr]
    args'
          | Maybe [Char]
    Nothing  <- Maybe [Char]
    name,
            Just [Dom' Term [Char]]
    ps' <- Hiding -> [Dom' Term [Char]] -> Maybe [Dom' Term [Char]]
    forall {a} {t}.
    (LensHiding a, LensHiding t) =>
    a -> [t] -> Maybe [t]
    unnamedPar Hiding
    h [Dom' Term [Char]]
    ps = [Dom' Term [Char]] -> [NamedArg Expr] -> [NamedArg Expr]
    dropArgs [Dom' Term [Char]]
    ps' [NamedArg Expr]
    args'
          | Bool
    otherwise                   = [NamedArg Expr]
    args
          where
            name :: Maybe [Char]
    name = NamedArg Expr -> Maybe [Char]
    forall a. (LensNamed a, NameOf a ~ NamedName) => a -> Maybe [Char]
    bareNameOf NamedArg Expr
    arg
            h :: Hiding
    h    = NamedArg Expr -> Hiding
    forall a. LensHiding a => a -> Hiding
    getHiding NamedArg Expr
    arg

            namedPar :: b -> [Dom' t b] -> Maybe [Dom' t b]
    namedPar   b
    x = (Dom' t b -> Bool) -> [Dom' t b] -> Maybe [Dom' t b]
    forall {t}. (t -> Bool) -> [t] -> Maybe [t]
    dropPar ((b
    x b -> b -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) (b -> Bool) -> (Dom' t b -> b) -> Dom' t b -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dom' t b -> b
    forall t e. Dom' t e -> e
    unDom)
            unnamedPar :: a -> [t] -> Maybe [t]
    unnamedPar a
    h = (t -> Bool) -> [t] -> Maybe [t]
    forall {t}. (t -> Bool) -> [t] -> Maybe [t]
    dropPar (a -> t -> Bool
    forall a b. (LensHiding a, LensHiding b) => a -> b -> Bool
    sameHiding a
    h)

            dropPar :: (t -> Bool) -> [t] -> Maybe [t]
    dropPar t -> Bool
    this (t
    p : [t]
    ps) | t -> Bool
    this t
    p    = [t] -> Maybe [t]
    forall a. a -> Maybe a
    Just [t]
    ps
                                  | Bool
    otherwise = (t -> Bool) -> [t] -> Maybe [t]
    dropPar t -> Bool
    this [t]
    ps
            dropPar t -> Bool
    _ [] = Maybe [t]
    forall a. Maybe a
    Nothing

    -- | Returns an unblocking action in case of failure.
    disambiguateConstructor :: List1 QName -> Type -> TCM (Either Blocker ConHead)
    disambiguateConstructor :: List1 QName -> Type -> TCM (Either Blocker ConHead)
    disambiguateConstructor List1 QName
    cs0 Type
    t = do
      [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.check.term.con" Nat
    40 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "Ambiguous constructor: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ List1 QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow List1 QName
    cs0

      -- Get the datatypes of the various constructors
      let getData :: Defn -> QName
    getData Constructor{conData :: Defn -> QName
    conData = QName
    d} = QName
    d
          getData Defn
    _                        = QName
    forall a. HasCallStack => a
    __IMPOSSIBLE__
      [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.check.term.con" Nat
    40 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  ranges before: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Range -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow (List1 QName -> Range
    forall a. HasRange a => a -> Range
    getRange List1 QName
    cs0)
      -- We use the reduced constructor when disambiguating, but
      -- the original constructor for type checking. This is important
      -- since they may have different types (different parameters).
      -- See issue 279.
      -- Andreas, 2017-08-13, issue #2686: ignore abstract constructors
      [(QName, ConHead)]
    ccons  <- List1 (Either SigError (QName, ConHead)) -> [(QName, ConHead)]
    forall a b. List1 (Either a b) -> [b]
    List1.rights (List1 (Either SigError (QName, ConHead)) -> [(QName, ConHead)])
    -> TCMT IO (List1 (Either SigError (QName, ConHead)))
    -> TCMT IO [(QName, ConHead)]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> do
         List1 QName
    -> (QName -> TCMT IO (Either SigError (QName, ConHead)))
    -> TCMT IO (List1 (Either SigError (QName, ConHead)))
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM List1 QName
    cs0 ((QName -> TCMT IO (Either SigError (QName, ConHead)))
     -> TCMT IO (List1 (Either SigError (QName, ConHead))))
    -> (QName -> TCMT IO (Either SigError (QName, ConHead)))
    -> TCMT IO (List1 (Either SigError (QName, ConHead)))
    forall a b. (a -> b) -> a -> b
    $ \ QName
    c -> (ConHead -> (QName, ConHead))
    -> Either SigError ConHead -> Either SigError (QName, ConHead)
    forall b d a. (b -> d) -> Either a b -> Either a d
    mapRight (QName
    c,) (Either SigError ConHead -> Either SigError (QName, ConHead))
    -> TCMT IO (Either SigError ConHead)
    -> TCMT IO (Either SigError (QName, ConHead))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> TCMT IO (Either SigError ConHead)
    getConForm QName
    c
      [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.check.term.con" Nat
    40 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  reduced: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [ConHead] -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow (((QName, ConHead) -> ConHead) -> [(QName, ConHead)] -> [ConHead]
    forall a b. (a -> b) -> [a] -> [b]
    map (QName, ConHead) -> ConHead
    forall a b. (a, b) -> b
    snd [(QName, ConHead)]
    ccons)
      case [(QName, ConHead)]
    ccons of
        []    -> TypeError -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (Either Blocker ConHead))
    -> TypeError -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ QName -> TypeError
    AbstractConstructorNotInScope (QName -> TypeError) -> QName -> TypeError
    forall a b. (a -> b) -> a -> b
    $ List1 QName -> QName
    forall a. NonEmpty a -> a
    List1.head List1 QName
    cs0
        [(QName
    c0,ConHead
    con)] -> do
          let c :: ConHead
    c = QName -> ConHead -> ConHead
    forall a. LensConName a => QName -> a -> a
    setConName QName
    c0 ConHead
    con
          [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.check.term.con" Nat
    40 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  only one non-abstract constructor: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ ConHead -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow ConHead
    c
          Induction -> QName -> TCMT IO ()
    storeDisambiguatedConstructor (ConHead -> Induction
    conInductive ConHead
    c) (ConHead -> QName
    conName ConHead
    c)
          Either Blocker ConHead -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (ConHead -> Either Blocker ConHead
    forall a b. b -> Either a b
    Right ConHead
    c)
        (QName
    c0,ConHead
    _):[(QName, ConHead)]
    _   -> do
          [(QName, ConHead)]
    dcs <- [(QName, ConHead)]
    -> ((QName, ConHead) -> TCMT IO (QName, ConHead))
    -> TCMT IO [(QName, ConHead)]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    t a -> (a -> m b) -> m (t b)
    forM [(QName, ConHead)]
    ccons (((QName, ConHead) -> TCMT IO (QName, ConHead))
     -> TCMT IO [(QName, ConHead)])
    -> ((QName, ConHead) -> TCMT IO (QName, ConHead))
    -> TCMT IO [(QName, ConHead)]
    forall a b. (a -> b) -> a -> b
    $ \ (QName
    c, ConHead
    con) -> (, QName -> ConHead -> ConHead
    forall a. LensConName a => QName -> a -> a
    setConName QName
    c ConHead
    con) (QName -> (QName, ConHead))
    -> (Definition -> QName) -> Definition -> (QName, ConHead)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Defn -> QName
    getData (Defn -> QName) -> (Definition -> Defn) -> Definition -> QName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Definition -> Defn
    theDef (Definition -> (QName, ConHead))
    -> TCMT IO Definition -> TCMT IO (QName, ConHead)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ConHead -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => ConHead -> m Definition
    getConInfo ConHead
    con
          -- Type error
          let badCon :: Type -> TCM (Either Blocker ConHead)
    badCon Type
    t = TypeError -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (Either Blocker ConHead))
    -> TypeError -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ QName -> Type -> TypeError
    DoesNotConstructAnElementOf QName
    c0 Type
    t
          -- Lets look at the target type at this point
          TelV Tele (Dom Type)
    tel Type
    t1 <- Type -> TCMT IO (TelV Type)
    forall (m :: * -> *). PureTCM m => Type -> m (TelV Type)
    telViewPath Type
    t
          Tele (Dom Type)
    -> TCM (Either Blocker ConHead) -> TCM (Either Blocker ConHead)
    forall b (m :: * -> *) a.
    (AddContext b, MonadAddContext m) =>
    b -> m a -> m a
    addContext Tele (Dom Type)
    tel (TCM (Either Blocker ConHead) -> TCM (Either Blocker ConHead))
    -> TCM (Either Blocker ConHead) -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ do
           [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.check.term.con" Nat
    40 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $
             TCMT IO Doc
    "target type: " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t1
           Type
    -> (Blocker -> Type -> TCM (Either Blocker ConHead))
    -> (NotBlocked -> Type -> TCM (Either Blocker ConHead))
    -> TCM (Either Blocker ConHead)
    forall t (m :: * -> *) a.
    (Reduce t, IsMeta t, MonadReduce m) =>
    t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a
    ifBlocked Type
    t1 (\ Blocker
    b Type
    t -> Either Blocker ConHead -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either Blocker ConHead -> TCM (Either Blocker ConHead))
    -> Either Blocker ConHead -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ Blocker -> Either Blocker ConHead
    forall a b. a -> Either a b
    Left Blocker
    b) ((NotBlocked -> Type -> TCM (Either Blocker ConHead))
     -> TCM (Either Blocker ConHead))
    -> (NotBlocked -> Type -> TCM (Either Blocker ConHead))
    -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ \ NotBlocked
    _ Type
    t' ->
             TCMT IO (Maybe QName)
    -> TCM (Either Blocker ConHead)
    -> (QName -> TCM (Either Blocker ConHead))
    -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (Term -> TCMT IO (Maybe QName)
    isDataOrRecord (Term -> TCMT IO (Maybe QName)) -> Term -> TCMT IO (Maybe QName)
    forall a b. (a -> b) -> a -> b
    $ Type -> Term
    forall t a. Type'' t a -> a
    unEl Type
    t') (Type -> TCM (Either Blocker ConHead)
    badCon Type
    t') ((QName -> TCM (Either Blocker ConHead))
     -> TCM (Either Blocker ConHead))
    -> (QName -> TCM (Either Blocker ConHead))
    -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ \ QName
    d ->
               case [ ConHead
    c | (QName
    d', ConHead
    c) <- [(QName, ConHead)]
    dcs, QName
    d QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    d' ] of
                 [ConHead
    c] -> do
                   [Char] -> Nat -> [Char] -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> [Char] -> m ()
    reportSLn [Char]
    "tc.check.term.con" Nat
    40 ([Char] -> TCMT IO ()) -> [Char] -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  decided on: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ ConHead -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow ConHead
    c
                   Induction -> QName -> TCMT IO ()
    storeDisambiguatedConstructor (ConHead -> Induction
    conInductive ConHead
    c) (ConHead -> QName
    conName ConHead
    c)
                   Either Blocker ConHead -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Either Blocker ConHead -> TCM (Either Blocker ConHead))
    -> Either Blocker ConHead -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ ConHead -> Either Blocker ConHead
    forall a b. b -> Either a b
    Right ConHead
    c
                 []  -> Type -> TCM (Either Blocker ConHead)
    badCon (Type -> TCM (Either Blocker ConHead))
    -> Type -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ Type
    t' Type -> Term -> Type
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $> QName -> Elims -> Term
    Def QName
    d []
                 ConHead
    c:[ConHead]
    cs-> TypeError -> TCM (Either Blocker ConHead)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (Either Blocker ConHead))
    -> TypeError -> TCM (Either Blocker ConHead)
    forall a b. (a -> b) -> a -> b
    $ QName -> List1 QName -> TypeError
    CantResolveOverloadedConstructorsTargetingSameDatatype QName
    d (List1 QName -> TypeError) -> List1 QName -> TypeError
    forall a b. (a -> b) -> a -> b
    $
                          (ConHead -> QName) -> NonEmpty ConHead -> List1 QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap ConHead -> QName
    conName (NonEmpty ConHead -> List1 QName)
    -> NonEmpty ConHead -> List1 QName
    forall a b. (a -> b) -> a -> b
    $ ConHead
    c ConHead -> [ConHead] -> NonEmpty ConHead
    forall a. a -> [a] -> NonEmpty a
    :| [ConHead]
    cs

    ---------------------------------------------------------------------------
    -- * Projections
    ---------------------------------------------------------------------------

    checkUnambiguousProjectionApplication :: Comparison -> A.Expr -> Type -> QName -> ProjOrigin -> A.Expr -> [NamedArg A.Expr] -> TCM Term
    checkUnambiguousProjectionApplication :: Comparison
    -> Expr
    -> Type
    -> QName
    -> ProjOrigin
    -> Expr
    -> [NamedArg Expr]
    -> TCM Term
    checkUnambiguousProjectionApplication Comparison
    cmp Expr
    e Type
    t QName
    x ProjOrigin
    o Expr
    hd [NamedArg Expr]
    args = do
      let fallback :: TCM Term
    fallback = Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    e Type
    t Expr
    hd [NamedArg Expr]
    args
      -- Andreas, 2021-02-19, issue #3289
      -- If a postfix projection was moved to the head by appView,
      -- we have to patch the first argument with the correct hiding info.
      case (ProjOrigin
    o, [NamedArg Expr]
    args) of
        (ProjOrigin
    ProjPostfix, NamedArg Expr
    arg : [NamedArg Expr]
    rest) -> do
          -- Andreas, 2021-11-19, issue #5657:
          -- If @x@ has been brought into scope by e.g. @open R r@, it is no longer
          -- a projection even though the scope checker labels it so.
          -- Thus, @isProjection@ may fail.
          TCMT IO (Maybe Projection)
    -> TCM Term -> (Projection -> TCM Term) -> TCM Term
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (QName -> TCMT IO (Maybe Projection)
    forall (m :: * -> *).
    HasConstInfo m =>
    QName -> m (Maybe Projection)
    isProjection QName
    x) TCM Term
    fallback ((Projection -> TCM Term) -> TCM Term)
    -> (Projection -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ Projection
    pr -> do
            Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    e Type
    t Expr
    hd (ArgInfo -> NamedArg Expr -> NamedArg Expr
    forall a. LensArgInfo a => ArgInfo -> a -> a
    setArgInfo (Projection -> ArgInfo
    projArgInfo Projection
    pr) NamedArg Expr
    arg NamedArg Expr -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. a -> [a] -> [a]
    : [NamedArg Expr]
    rest)
        (ProjOrigin, [NamedArg Expr])
    _ -> TCM Term
    fallback

    -- | Inferring the type of an overloaded projection application.
    --   See 'inferOrCheckProjApp'.

    inferProjApp :: A.Expr -> ProjOrigin -> List1 QName -> A.Args -> TCM (Term, Type)
    inferProjApp :: Expr
    -> ProjOrigin -> List1 QName -> [NamedArg Expr] -> TCM (Term, Type)
    inferProjApp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 = do
      (Term
    v, Type
    t, CheckedTarget
    _) <- Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjApp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 Maybe (Comparison, Type)
    forall a. Maybe a
    Nothing
      (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    t)

    -- | Checking the type of an overloaded projection application.
    --   See 'inferOrCheckProjApp'.

    checkProjApp  :: Comparison -> A.Expr -> ProjOrigin -> List1 QName -> A.Args -> Type -> TCM Term
    checkProjApp :: Comparison
    -> Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Type
    -> TCM Term
    checkProjApp Comparison
    cmp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 Type
    t = do
      (Term
    v, Type
    ti, CheckedTarget
    targetCheck) <- Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjApp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 ((Comparison, Type) -> Maybe (Comparison, Type)
    forall a. a -> Maybe a
    Just (Comparison
    cmp, Type
    t))
      Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    targetCheck Term
    v Type
    ti Type
    t

    -- | Checking the type of an overloaded projection application.
    --   See 'inferOrCheckProjAppToKnownPrincipalArg'.

    checkProjAppToKnownPrincipalArg  :: Comparison -> A.Expr -> ProjOrigin -> List1 QName -> A.Args -> Type -> Int -> Term -> Type -> PrincipalArgTypeMetas -> TCM Term
    checkProjAppToKnownPrincipalArg :: Comparison
    -> Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Type
    -> Nat
    -> Term
    -> Type
    -> PrincipalArgTypeMetas
    -> TCM Term
    checkProjAppToKnownPrincipalArg Comparison
    cmp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 Type
    t Nat
    k Term
    v0 Type
    pt PrincipalArgTypeMetas
    patm = do
      (Term
    v, Type
    ti, CheckedTarget
    targetCheck) <- Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> Nat
    -> Term
    -> Type
    -> Maybe PrincipalArgTypeMetas
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjAppToKnownPrincipalArg Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args0 ((Comparison, Type) -> Maybe (Comparison, Type)
    forall a. a -> Maybe a
    Just (Comparison
    cmp, Type
    t)) Nat
    k Term
    v0 Type
    pt (PrincipalArgTypeMetas -> Maybe PrincipalArgTypeMetas
    forall a. a -> Maybe a
    Just PrincipalArgTypeMetas
    patm)
      Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    targetCheck Term
    v Type
    ti Type
    t

    -- | Inferring or Checking an overloaded projection application.
    --
    --   The overloaded projection is disambiguated by inferring the type of its
    --   principal argument, which is the first visible argument.

    inferOrCheckProjApp
      :: A.Expr
         -- ^ The whole expression which constitutes the application.
      -> ProjOrigin
         -- ^ The origin of the projection involved in this projection application.
      -> List1 QName
         -- ^ The projection name (potentially ambiguous).
      -> A.Args
         -- ^ The arguments to the projection.
      -> Maybe (Comparison, Type)
         -- ^ The expected type of the expression (if 'Nothing', infer it).
      -> TCM (Term, Type, CheckedTarget)
         -- ^ The type-checked expression and its type (if successful).
    inferOrCheckProjApp :: Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjApp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args Maybe (Comparison, Type)
    mt = do
      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    20 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
        [ TCMT IO Doc
    "checking ambiguous projection"
        , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  ds   = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ List1 QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow List1 QName
    ds
        , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text   [Char]
    "  args = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    sep ((NamedArg Expr -> TCMT IO Doc) -> [NamedArg Expr] -> [TCMT IO Doc]
    forall a b. (a -> b) -> [a] -> [b]
    map NamedArg Expr -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM [NamedArg Expr]
    args)
        , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text   [Char]
    "  t    = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Maybe (Comparison, Type)
    -> TCMT IO Doc
    -> ((Comparison, Type) -> TCMT IO Doc)
    -> TCMT IO Doc
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt TCMT IO Doc
    "Nothing" (Comparison, Type) -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM
        ]

      let cmp :: Comparison
    cmp = Maybe (Comparison, Type)
    -> Comparison -> ((Comparison, Type) -> Comparison) -> Comparison
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt Comparison
    CmpEq (Comparison, Type) -> Comparison
    forall a b. (a, b) -> a
    fst

          -- Postpone the whole type checking problem
          -- if type of principal argument (or the type where we get it from)
          -- is blocked by meta m.
          postpone :: Blocker -> TCM (Term, Type, CheckedTarget)
    postpone Blocker
    b = do
            Type
    tc <- Maybe (Comparison, Type)
    -> TCMT IO Type
    -> ((Comparison, Type) -> TCMT IO Type)
    -> TCMT IO Type
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt TCMT IO Type
    newTypeMeta_ (Type -> TCMT IO Type
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCMT IO Type)
    -> ((Comparison, Type) -> Type)
    -> (Comparison, Type)
    -> TCMT IO Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Comparison, Type) -> Type
    forall a b. (a, b) -> b
    snd)
            Term
    v <- TypeCheckingProblem -> Blocker -> TCM Term
    postponeTypeCheckingProblem (Comparison -> Expr -> Type -> TypeCheckingProblem
    CheckExpr Comparison
    cmp Expr
    e Type
    tc) Blocker
    b
            (Term, Type, CheckedTarget) -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    tc, CheckedTarget
    NotCheckedTarget)

      -- The following cases need to be considered:
      -- 1. No arguments to the projection.
      -- 2. Arguments (parameters), but not the principal argument.
      -- 3. Argument(s) including the principal argument.

      -- For now, we only allow ambiguous projections if the first visible
      -- argument is the record value.

      case ((Nat, NamedArg Expr) -> Bool)
    -> [(Nat, NamedArg Expr)] -> [(Nat, NamedArg Expr)]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (NamedArg Expr -> Bool
    forall a. LensHiding a => a -> Bool
    visible (NamedArg Expr -> Bool)
    -> ((Nat, NamedArg Expr) -> NamedArg Expr)
    -> (Nat, NamedArg Expr)
    -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Nat, NamedArg Expr) -> NamedArg Expr
    forall a b. (a, b) -> b
    snd) ([(Nat, NamedArg Expr)] -> [(Nat, NamedArg Expr)])
    -> [(Nat, NamedArg Expr)] -> [(Nat, NamedArg Expr)]
    forall a b. (a -> b) -> a -> b
    $ [Nat] -> [NamedArg Expr] -> [(Nat, NamedArg Expr)]
    forall a b. [a] -> [b] -> [(a, b)]
    zip [Nat
    0..] [NamedArg Expr]
    args of

        -- Case: we have no visible argument to the projection.
        -- In inference mode, we really need the visible argument, postponing does not help
        [] -> Maybe (Comparison, Type)
    -> TCM (Term, Type, CheckedTarget)
    -> ((Comparison, Type) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt (List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNotApplied List1 QName
    ds) (((Comparison, Type) -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> ((Comparison, Type) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ \ (Comparison
    cmp , Type
    t) -> do
          -- If we have the type, we can try to get the type of the principal argument.
          -- It is the first visible argument.
          TelV Tele (Dom Type)
    _ptel Type
    core <- Nat -> (Dom Type -> Bool) -> Type -> TCMT IO (TelV Type)
    forall (m :: * -> *).
    (MonadReduce m, MonadAddContext m) =>
    Nat -> (Dom Type -> Bool) -> Type -> m (TelV Type)
    telViewUpTo' (-Nat
    1) (Bool -> Bool
    not (Bool -> Bool) -> (Dom Type -> Bool) -> Dom Type -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dom Type -> Bool
    forall a. LensHiding a => a -> Bool
    visible) Type
    t
          Type
    -> (Blocker -> Type -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall t (m :: * -> *) a.
    (Reduce t, IsMeta t, MonadReduce m) =>
    t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a
    ifBlocked Type
    core (\ Blocker
    m Type
    _ -> Blocker -> TCM (Term, Type, CheckedTarget)
    postpone Blocker
    m) ((NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ {-else-} \ NotBlocked
    _ Type
    core -> do
          Type
    -> (Type -> TCM (Term, Type, CheckedTarget))
    -> (Dom Type -> Abs Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a.
    MonadReduce m =>
    Type -> (Type -> m a) -> (Dom Type -> Abs Type -> m a) -> m a
    ifNotPiType Type
    core (\ Type
    _ -> List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNotApplied List1 QName
    ds) ((Dom Type -> Abs Type -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> (Dom Type -> Abs Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ {-else-} \ Dom Type
    dom Abs Type
    _b -> do
          Type
    -> (Blocker -> Type -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall t (m :: * -> *) a.
    (Reduce t, IsMeta t, MonadReduce m) =>
    t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a
    ifBlocked (Dom Type -> Type
    forall t e. Dom' t e -> e
    unDom Dom Type
    dom) (\ Blocker
    m Type
    _ -> Blocker -> TCM (Term, Type, CheckedTarget)
    postpone Blocker
    m) ((NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ {-else-} \ NotBlocked
    _ Type
    ta -> do
          TCMT IO (Maybe (QName, Args, Defn))
    -> TCM (Term, Type, CheckedTarget)
    -> ((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (Type -> TCMT IO (Maybe (QName, Args, Defn))
    forall (m :: * -> *).
    PureTCM m =>
    Type -> m (Maybe (QName, Args, Defn))
    isRecordType Type
    ta) (List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNotRecordType List1 QName
    ds) (((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> ((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ \ (QName
    _q, Args
    _pars, Defn
    defn) -> do
          case Defn
    defn of
            Record { recFields :: Defn -> [Dom QName]
    recFields = [Dom QName]
    fs } -> do
              case [Dom QName] -> (Dom QName -> Maybe QName) -> [QName]
    forall a b. [a] -> (a -> Maybe b) -> [b]
    forMaybe [Dom QName]
    fs ((Dom QName -> Maybe QName) -> [QName])
    -> (Dom QName -> Maybe QName) -> [QName]
    forall a b. (a -> b) -> a -> b
    $ \ Dom QName
    f -> (QName -> Bool) -> List1 QName -> Maybe QName
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
    Fold.find (Dom QName -> QName
    forall t e. Dom' t e -> e
    unDom Dom QName
    f QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    ==) List1 QName
    ds of
                [] -> List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNoMatching List1 QName
    ds
                [QName
    d] -> do
                  QName -> TCMT IO ()
    storeDisambiguatedProjection QName
    d
                  -- checkHeadApplication will check the target type
                  (, Type
    t, Maybe ProblemId -> CheckedTarget
    CheckedTarget Maybe ProblemId
    forall a. Maybe a
    Nothing) (Term -> (Term, Type, CheckedTarget))
    -> TCM Term -> TCM (Term, Type, CheckedTarget)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
                    Comparison -> Expr -> Type -> Expr -> [NamedArg Expr] -> TCM Term
    checkHeadApplication Comparison
    cmp Expr
    e Type
    t (ProjOrigin -> AmbiguousQName -> Expr
    A.Proj ProjOrigin
    o (AmbiguousQName -> Expr) -> AmbiguousQName -> Expr
    forall a b. (a -> b) -> a -> b
    $ QName -> AmbiguousQName
    unambiguous QName
    d) [NamedArg Expr]
    args
                [QName]
    _ -> TCM (Term, Type, CheckedTarget)
    forall a. HasCallStack => a
    __IMPOSSIBLE__
            Defn
    _ -> TCM (Term, Type, CheckedTarget)
    forall a. HasCallStack => a
    __IMPOSSIBLE__

        -- Case: we have a visible argument
        ((Nat
    k, NamedArg Expr
    arg) : [(Nat, NamedArg Expr)]
    _) -> do
          (Term
    v0, Type
    ta) <- Expr -> TCM (Term, Type)
    inferExpr (Expr -> TCM (Term, Type)) -> Expr -> TCM (Term, Type)
    forall a b. (a -> b) -> a -> b
    $ NamedArg Expr -> Expr
    forall a. NamedArg a -> a
    namedArg NamedArg Expr
    arg
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    25 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
            [ TCMT IO Doc
    "  principal arg " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> NamedArg Expr -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM NamedArg Expr
    arg
            , TCMT IO Doc
    "  has type "      TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    ta
            ]
          Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> Nat
    -> Term
    -> Type
    -> Maybe PrincipalArgTypeMetas
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjAppToKnownPrincipalArg Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args Maybe (Comparison, Type)
    mt Nat
    k Term
    v0 Type
    ta Maybe PrincipalArgTypeMetas
    forall a. Maybe a
    Nothing

    -- | Same arguments 'inferOrCheckProjApp' above but also gets the position,
    --   value and type of the principal argument.
    inferOrCheckProjAppToKnownPrincipalArg
      :: A.Expr
         -- ^ The whole expression which constitutes the application.
      -> ProjOrigin
         -- ^ The origin of the projection involved in this projection application.
      -> List1 QName
         -- ^ The projection name (potentially ambiguous).
      -> A.Args
         -- ^ The arguments to the projection.
      -> Maybe (Comparison, Type)
         -- ^ The expected type of the expression (if 'Nothing', infer it).
      -> Int
         -- ^ The position of the principal argument.
      -> Term
         -- ^ The value of the principal argument.
      -> Type
         -- ^ The type of the principal argument.
      -> Maybe PrincipalArgTypeMetas
         -- ^ The metas previously created for the principal argument's type, when
         --   picking up a postponed problem. 'Nothing', otherwise.
      -> TCM (Term, Type, CheckedTarget)
         -- ^ The type-checked expression and its type (if successful).
    inferOrCheckProjAppToKnownPrincipalArg :: Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Maybe (Comparison, Type)
    -> Nat
    -> Term
    -> Type
    -> Maybe PrincipalArgTypeMetas
    -> TCM (Term, Type, CheckedTarget)
    inferOrCheckProjAppToKnownPrincipalArg Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args Maybe (Comparison, Type)
    mt Nat
    k Term
    v0 Type
    ta Maybe PrincipalArgTypeMetas
    mpatm = do
      let cmp :: Comparison
    cmp = Maybe (Comparison, Type)
    -> Comparison -> ((Comparison, Type) -> Comparison) -> Comparison
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt Comparison
    CmpEq (Comparison, Type) -> Comparison
    forall a b. (a, b) -> a
    fst
          postpone :: Blocker -> PrincipalArgTypeMetas -> TCM (Term, Type, CheckedTarget)
    postpone Blocker
    b PrincipalArgTypeMetas
    patm = do
            Type
    tc <- Maybe (Comparison, Type)
    -> TCMT IO Type
    -> ((Comparison, Type) -> TCMT IO Type)
    -> TCMT IO Type
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt TCMT IO Type
    newTypeMeta_ (Type -> TCMT IO Type
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCMT IO Type)
    -> ((Comparison, Type) -> Type)
    -> (Comparison, Type)
    -> TCMT IO Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Comparison, Type) -> Type
    forall a b. (a, b) -> b
    snd)
            Term
    v <- TypeCheckingProblem -> Blocker -> TCM Term
    postponeTypeCheckingProblem (Comparison
    -> Expr
    -> ProjOrigin
    -> List1 QName
    -> [NamedArg Expr]
    -> Type
    -> Nat
    -> Term
    -> Type
    -> PrincipalArgTypeMetas
    -> TypeCheckingProblem
    CheckProjAppToKnownPrincipalArg Comparison
    cmp Expr
    e ProjOrigin
    o List1 QName
    ds [NamedArg Expr]
    args Type
    tc Nat
    k Term
    v0 Type
    ta PrincipalArgTypeMetas
    patm) Blocker
    b
            (Term, Type, CheckedTarget) -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    tc, CheckedTarget
    NotCheckedTarget)
      -- ta should be a record type (after introducing the hidden args in v0)
      patm :: PrincipalArgTypeMetas
    patm@(PrincipalArgTypeMetas Args
    vargs Type
    ta) <- case Maybe PrincipalArgTypeMetas
    mpatm of
        -- keep using the previously created metas, when picking up a postponed
        -- problem - see #4924
        Just PrincipalArgTypeMetas
    patm -> PrincipalArgTypeMetas -> TCMT IO PrincipalArgTypeMetas
    forall (m :: * -> *) a. Monad m => a -> m a
    return PrincipalArgTypeMetas
    patm
        -- create fresh metas
        Maybe PrincipalArgTypeMetas
    Nothing -> (Args -> Type -> PrincipalArgTypeMetas)
    -> (Args, Type) -> PrincipalArgTypeMetas
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry Args -> Type -> PrincipalArgTypeMetas
    PrincipalArgTypeMetas ((Args, Type) -> PrincipalArgTypeMetas)
    -> TCM (Args, Type) -> TCMT IO PrincipalArgTypeMetas
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Nat -> (Hiding -> Bool) -> Type -> TCM (Args, Type)
    forall (m :: * -> *).
    (PureTCM m, MonadMetaSolver m, MonadTCM m) =>
    Nat -> (Hiding -> Bool) -> Type -> m (Args, Type)
    implicitArgs (-Nat
    1) (Bool -> Bool
    not (Bool -> Bool) -> (Hiding -> Bool) -> Hiding -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Hiding -> Bool
    forall a. LensHiding a => a -> Bool
    visible) Type
    ta
      let v :: Term
    v = Term
    v0 Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` Args
    vargs
      Type
    -> (Blocker -> Type -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall t (m :: * -> *) a.
    (Reduce t, IsMeta t, MonadReduce m) =>
    t -> (Blocker -> t -> m a) -> (NotBlocked -> t -> m a) -> m a
    ifBlocked Type
    ta (\ Blocker
    m Type
    _ -> Blocker -> PrincipalArgTypeMetas -> TCM (Term, Type, CheckedTarget)
    postpone Blocker
    m PrincipalArgTypeMetas
    patm) {-else-} ((NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> (NotBlocked -> Type -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ \ NotBlocked
    _ Type
    ta -> do
      TCMT IO (Maybe (QName, Args, Defn))
    -> TCM (Term, Type, CheckedTarget)
    -> ((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (Type -> TCMT IO (Maybe (QName, Args, Defn))
    forall (m :: * -> *).
    PureTCM m =>
    Type -> m (Maybe (QName, Args, Defn))
    isRecordType Type
    ta) (List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNotRecordType List1 QName
    ds) (((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
     -> TCM (Term, Type, CheckedTarget))
    -> ((QName, Args, Defn) -> TCM (Term, Type, CheckedTarget))
    -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ \ (QName
    q, Args
    _pars0, Defn
    _) -> do

          -- try to project it with all of the possible projections
          let try :: QName
    -> MaybeT
         (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type))))
    try QName
    d = do
                [Char] -> Nat -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    30 (TCMT IO Doc -> MaybeT (TCMT IO) ())
    -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                  [ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "trying projection " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow QName
    d
                  , TCMT IO Doc
    "  td  = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO (Maybe Type)
    -> TCMT IO Doc -> (Type -> TCMT IO Doc) -> TCMT IO Doc
    forall (m :: * -> *) a b.
    Monad m =>
    m (Maybe a) -> m b -> (a -> m b) -> m b
    caseMaybeM (QName -> Type -> TCMT IO (Maybe Type)
    forall (m :: * -> *). PureTCM m => QName -> Type -> m (Maybe Type)
    getDefType QName
    d Type
    ta) TCMT IO Doc
    "Nothing" Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM
                  ]

                -- get the original projection name
                Definition
    def <- TCMT IO Definition -> MaybeT (TCMT IO) Definition
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO Definition -> MaybeT (TCMT IO) Definition)
    -> TCMT IO Definition -> MaybeT (TCMT IO) Definition
    forall a b. (a -> b) -> a -> b
    $ QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    d
                let isP :: Maybe Projection
    isP = Defn -> Maybe Projection
    isProjection_ (Defn -> Maybe Projection) -> Defn -> Maybe Projection
    forall a b. (a -> b) -> a -> b
    $ Definition -> Defn
    theDef Definition
    def
                [Char] -> Nat -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    40 (TCMT IO Doc -> MaybeT (TCMT IO) ())
    -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat ([TCMT IO Doc] -> TCMT IO Doc) -> [TCMT IO Doc] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $
                  [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ( [Char]
    "  isProjection = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Maybe Projection -> [Char] -> (Projection -> [Char]) -> [Char]
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe Projection
    isP [Char]
    "no" ([Char] -> Projection -> [Char]
    forall a b. a -> b -> a
    const [Char]
    "yes")
                       ) TCMT IO Doc -> [TCMT IO Doc] -> [TCMT IO Doc]
    forall a. a -> [a] -> [a]
    : Maybe Projection
    -> [TCMT IO Doc] -> (Projection -> [TCMT IO Doc]) -> [TCMT IO Doc]
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe Projection
    isP [] (\ Projection{ projProper :: Projection -> Maybe QName
    projProper = Maybe QName
    proper, projOrig :: Projection -> QName
    projOrig = QName
    orig } ->
                  [ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  proper       = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Maybe QName -> [Char]
    forall a. Show a => a -> [Char]
    show Maybe QName
    proper
                  , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  orig         = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow QName
    orig
                  ])

                -- Andreas, 2017-01-21, issue #2422
                -- The scope checker considers inherited projections (from nested records)
                -- as projections and allows overloading.  However, since they are defined
                -- as *composition* of projections, the type checker does *not* recognize them,
                -- and @isP@ will be @Nothing@.
                -- However, we can ignore this, as we only need the @orig@inal projection name
                -- for removing false ambiguity.  Thus, we skip these checks:

                -- Projection{ projProper = proper, projOrig = orig } <- MaybeT $ return isP
                -- guard $ isJust proper
                let orig :: QName
    orig = Maybe Projection -> QName -> (Projection -> QName) -> QName
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe Projection
    isP QName
    d Projection -> QName
    projOrig

                -- try to eliminate
                (Dom Type
    dom, Term
    u, Type
    tb) <- TCMT IO (Maybe (Dom Type, Term, Type))
    -> MaybeT (TCMT IO) (Dom Type, Term, Type)
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (Term
    -> Type
    -> ProjOrigin
    -> QName
    -> TCMT IO (Maybe (Dom Type, Term, Type))
    forall (m :: * -> *).
    PureTCM m =>
    Term
    -> Type -> ProjOrigin -> QName -> m (Maybe (Dom Type, Term, Type))
    projectTyped Term
    v Type
    ta ProjOrigin
    o QName
    d TCMT IO (Maybe (Dom Type, Term, Type))
    -> (TCErr -> TCMT IO (Maybe (Dom Type, Term, Type)))
    -> TCMT IO (Maybe (Dom Type, Term, Type))
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    `catchError` \ TCErr
    _ -> Maybe (Dom Type, Term, Type)
    -> TCMT IO (Maybe (Dom Type, Term, Type))
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe (Dom Type, Term, Type)
    forall a. Maybe a
    Nothing)
                [Char] -> Nat -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    30 (TCMT IO Doc -> MaybeT (TCMT IO) ())
    -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                  [ TCMT IO Doc
    "  dom = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Dom Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Dom Type
    dom
                  , TCMT IO Doc
    "  u   = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Term
    u
                  , TCMT IO Doc
    "  tb  = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    tb
                  ]
                (QName
    q', Args
    pars, Defn
    _) <- TCMT IO (Maybe (QName, Args, Defn))
    -> MaybeT (TCMT IO) (QName, Args, Defn)
    forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
    MaybeT (TCMT IO (Maybe (QName, Args, Defn))
     -> MaybeT (TCMT IO) (QName, Args, Defn))
    -> TCMT IO (Maybe (QName, Args, Defn))
    -> MaybeT (TCMT IO) (QName, Args, Defn)
    forall a b. (a -> b) -> a -> b
    $ Type -> TCMT IO (Maybe (QName, Args, Defn))
    forall (m :: * -> *).
    PureTCM m =>
    Type -> m (Maybe (QName, Args, Defn))
    isRecordType (Type -> TCMT IO (Maybe (QName, Args, Defn)))
    -> Type -> TCMT IO (Maybe (QName, Args, Defn))
    forall a b. (a -> b) -> a -> b
    $ Dom Type -> Type
    forall t e. Dom' t e -> e
    unDom Dom Type
    dom
                [Char] -> Nat -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    30 (TCMT IO Doc -> MaybeT (TCMT IO) ())
    -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                  [ TCMT IO Doc
    "  q   = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    q
                  , TCMT IO Doc
    "  q'  = " TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    q'
                  ]
                Bool -> MaybeT (TCMT IO) ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (QName
    q QName -> QName -> Bool
    forall a. Eq a => a -> a -> Bool
    == QName
    q')
                -- Get the type of the projection and check
                -- that the first visible argument is the record value.
                let tfull :: Type
    tfull = Definition -> Type
    defType Definition
    def
                TelV Tele (Dom Type)
    tel Type
    _ <- TCMT IO (TelV Type) -> MaybeT (TCMT IO) (TelV Type)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCMT IO (TelV Type) -> MaybeT (TCMT IO) (TelV Type))
    -> TCMT IO (TelV Type) -> MaybeT (TCMT IO) (TelV Type)
    forall a b. (a -> b) -> a -> b
    $ Nat -> (Dom Type -> Bool) -> Type -> TCMT IO (TelV Type)
    forall (m :: * -> *).
    (MonadReduce m, MonadAddContext m) =>
    Nat -> (Dom Type -> Bool) -> Type -> m (TelV Type)
    telViewUpTo' (-Nat
    1) (Bool -> Bool
    not (Bool -> Bool) -> (Dom Type -> Bool) -> Dom Type -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Dom Type -> Bool
    forall a. LensHiding a => a -> Bool
    visible) Type
    tfull
                [Char] -> Nat -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.proj.amb" Nat
    30 (TCMT IO Doc -> MaybeT (TCMT IO) ())
    -> TCMT IO Doc -> MaybeT (TCMT IO) ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat
                  [ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  size tel  = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Nat -> [Char]
    forall a. Show a => a -> [Char]
    show (Tele (Dom Type) -> Nat
    forall a. Sized a => a -> Nat
    size Tele (Dom Type)
    tel)
                  , [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text ([Char] -> TCMT IO Doc) -> [Char] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "  size pars = " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Nat -> [Char]
    forall a. Show a => a -> [Char]
    show (Args -> Nat
    forall a. Sized a => a -> Nat
    size Args
    pars)
                  ]
                -- See issue 1960 for when the following assertion fails for
                -- the correct disambiguation.
                -- guard (size tel == size pars)

                Bool -> MaybeT (TCMT IO) ()
    forall (f :: * -> *). Alternative f => Bool -> f ()
    guard (Bool -> MaybeT (TCMT IO) ())
    -> MaybeT (TCMT IO) Bool -> MaybeT (TCMT IO) ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< do Maybe TypeError -> Bool
    forall a. Maybe a -> Bool
    isNothing (Maybe TypeError -> Bool)
    -> MaybeT (TCMT IO) (Maybe TypeError) -> MaybeT (TCMT IO) Bool
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> do TCM (Maybe TypeError) -> MaybeT (TCMT IO) (Maybe TypeError)
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (TCM (Maybe TypeError) -> MaybeT (TCMT IO) (Maybe TypeError))
    -> TCM (Maybe TypeError) -> MaybeT (TCMT IO) (Maybe TypeError)
    forall a b. (a -> b) -> a -> b
    $ QName -> Definition -> TCM (Maybe TypeError)
    checkModality' QName
    d Definition
    def
                (QName, (QName, (Args, (Dom Type, Term, Type))))
    -> MaybeT
         (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type))))
    forall (m :: * -> *) a. Monad m => a -> m a
    return (QName
    orig, (QName
    d, (Args
    pars, (Dom Type
    dom, Term
    u, Type
    tb))))

          [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    cands <- ((QName, (QName, (Args, (Dom Type, Term, Type)))) -> QName)
    -> [(QName, (QName, (Args, (Dom Type, Term, Type))))]
    -> [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    forall b a. Ord b => (a -> b) -> [a] -> [[a]]
    groupOn (QName, (QName, (Args, (Dom Type, Term, Type)))) -> QName
    forall a b. (a, b) -> a
    fst ([(QName, (QName, (Args, (Dom Type, Term, Type))))]
     -> [[(QName, (QName, (Args, (Dom Type, Term, Type))))]])
    -> (List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
        -> [(QName, (QName, (Args, (Dom Type, Term, Type))))])
    -> List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
    -> [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
    -> [(QName, (QName, (Args, (Dom Type, Term, Type))))]
    forall a. List1 (Maybe a) -> [a]
    List1.catMaybes (List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
     -> [[(QName, (QName, (Args, (Dom Type, Term, Type))))]])
    -> TCMT
         IO (List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type))))))
    -> TCMT IO [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (QName
     -> TCMT
          IO (Maybe (QName, (QName, (Args, (Dom Type, Term, Type))))))
    -> List1 QName
    -> TCMT
         IO (List1 (Maybe (QName, (QName, (Args, (Dom Type, Term, Type))))))
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (MaybeT (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type))))
    -> TCMT IO (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
    forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
    runMaybeT (MaybeT (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type))))
     -> TCMT
          IO (Maybe (QName, (QName, (Args, (Dom Type, Term, Type))))))
    -> (QName
        -> MaybeT
             (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type)))))
    -> QName
    -> TCMT IO (Maybe (QName, (QName, (Args, (Dom Type, Term, Type)))))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . QName
    -> MaybeT
         (TCMT IO) (QName, (QName, (Args, (Dom Type, Term, Type))))
    try) List1 QName
    ds
          case [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    cands of
            [] -> List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNoMatching List1 QName
    ds
            [[]] -> List1 QName -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> TCM a
    refuseProjNoMatching List1 QName
    ds
            ([(QName, (QName, (Args, (Dom Type, Term, Type))))]
    _:[(QName, (QName, (Args, (Dom Type, Term, Type))))]
    _:[[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    _) -> List1 QName -> [Char] -> TCM (Term, Type, CheckedTarget)
    forall a. List1 QName -> [Char] -> TCM a
    refuseProj List1 QName
    ds ([Char] -> TCM (Term, Type, CheckedTarget))
    -> [Char] -> TCM (Term, Type, CheckedTarget)
    forall a b. (a -> b) -> a -> b
    $ [Char]
    "several matching candidates found: "
                 [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [QName] -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow (((QName, (QName, (Args, (Dom Type, Term, Type)))) -> QName)
    -> [(QName, (QName, (Args, (Dom Type, Term, Type))))] -> [QName]
    forall a b. (a -> b) -> [a] -> [b]
    map ((QName, (Args, (Dom Type, Term, Type))) -> QName
    forall a b. (a, b) -> a
    fst ((QName, (Args, (Dom Type, Term, Type))) -> QName)
    -> ((QName, (QName, (Args, (Dom Type, Term, Type))))
        -> (QName, (Args, (Dom Type, Term, Type))))
    -> (QName, (QName, (Args, (Dom Type, Term, Type))))
    -> QName
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (QName, (QName, (Args, (Dom Type, Term, Type))))
    -> (QName, (Args, (Dom Type, Term, Type)))
    forall a b. (a, b) -> b
    snd) ([(QName, (QName, (Args, (Dom Type, Term, Type))))] -> [QName])
    -> [(QName, (QName, (Args, (Dom Type, Term, Type))))] -> [QName]
    forall a b. (a -> b) -> a -> b
    $ [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    -> [(QName, (QName, (Args, (Dom Type, Term, Type))))]
    forall (t :: * -> *) a. Foldable t => t [a] -> [a]
    concat [[(QName, (QName, (Args, (Dom Type, Term, Type))))]]
    cands)
            -- case: just one matching projection d
            -- the term u = d v
            -- the type tb is the type of this application
            [ (QName
    _orig, (QName
    d, (Args
    pars, (Dom Type
    _dom,Term
    u,Type
    tb)))) : [(QName, (QName, (Args, (Dom Type, Term, Type))))]
    _ ] -> do
              QName -> TCMT IO ()
    storeDisambiguatedProjection QName
    d

              -- Check parameters
              Type
    tfull <- QName -> TCMT IO Type
    forall (m :: * -> *).
    (HasConstInfo m, ReadTCState m) =>
    QName -> m Type
    typeOfConst QName
    d
              (Args
    _,Type
    _) <- [NamedArg Expr] -> Args -> Type -> TCM (Args, Type)
    checkKnownArguments (Nat -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. Nat -> [a] -> [a]
    take Nat
    k [NamedArg Expr]
    args) Args
    pars Type
    tfull

              -- Check remaining arguments
              let r :: Range
    r     = Expr -> Range
    forall a. HasRange a => a -> Range
    getRange Expr
    e
                  args' :: [NamedArg Expr]
    args' = Nat -> [NamedArg Expr] -> [NamedArg Expr]
    forall a. Nat -> [a] -> [a]
    drop (Nat
    k Nat -> Nat -> Nat
    forall a. Num a => a -> a -> a
    + Nat
    1) [NamedArg Expr]
    args
              Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z <- ExceptT
      (ArgsCheckState [NamedArg Expr])
      (TCMT IO)
      (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
    runExceptT (ExceptT
       (ArgsCheckState [NamedArg Expr])
       (TCMT IO)
       (ArgsCheckState CheckedTarget)
     -> TCM
          (Either
             (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)))
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    -> TCM
         (Either
            (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget))
    forall a b. (a -> b) -> a -> b
    $ Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> Maybe Type
    -> ExceptT
         (ArgsCheckState [NamedArg Expr])
         (TCMT IO)
         (ArgsCheckState CheckedTarget)
    checkArgumentsE Comparison
    cmp ExpandHidden
    ExpandLast Range
    r [NamedArg Expr]
    args' Type
    tb ((Comparison, Type) -> Type
    forall a b. (a, b) -> b
    snd ((Comparison, Type) -> Type)
    -> Maybe (Comparison, Type) -> Maybe Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Maybe (Comparison, Type)
    mt)
              case Either
      (ArgsCheckState [NamedArg Expr]) (ArgsCheckState CheckedTarget)
    z of
                Right st :: ArgsCheckState CheckedTarget
    st@(ACState MaybeRanges
    _ Elims
    _ [Maybe (Abs Constraint)]
    _ Type
    trest CheckedTarget
    targetCheck) -> do
                  Term
    v <- (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints (Term
    u Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    `applyE`) ArgsCheckState CheckedTarget
    st
                  (Term, Type, CheckedTarget) -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    trest, CheckedTarget
    targetCheck)
                Left ArgsCheckState [NamedArg Expr]
    problem -> do
                  -- In the inference case:
                  -- To create a postponed type checking problem,
                  -- we do not use typeDontCare, but create a meta.
                  Type
    tc <- Maybe (Comparison, Type)
    -> TCMT IO Type
    -> ((Comparison, Type) -> TCMT IO Type)
    -> TCMT IO Type
    forall a b. Maybe a -> b -> (a -> b) -> b
    caseMaybe Maybe (Comparison, Type)
    mt TCMT IO Type
    newTypeMeta_ (Type -> TCMT IO Type
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCMT IO Type)
    -> ((Comparison, Type) -> Type)
    -> (Comparison, Type)
    -> TCMT IO Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Comparison, Type) -> Type
    forall a b. (a, b) -> b
    snd)
                  Term
    v  <- ArgsCheckState [NamedArg Expr]
    -> Comparison
    -> ExpandHidden
    -> Range
    -> [NamedArg Expr]
    -> Type
    -> (ArgsCheckState CheckedTarget -> TCM Term)
    -> TCM Term
    postponeArgs ArgsCheckState [NamedArg Expr]
    problem Comparison
    cmp ExpandHidden
    ExpandLast Range
    r [NamedArg Expr]
    args' Type
    tc ((ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term)
    -> (ArgsCheckState CheckedTarget -> TCM Term) -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ \ st :: ArgsCheckState CheckedTarget
    st@(ACState MaybeRanges
    _ Elims
    _ [Maybe (Abs Constraint)]
    _ Type
    trest CheckedTarget
    targetCheck) -> do
                          Term
    v <- (Elims -> Term) -> ArgsCheckState CheckedTarget -> TCM Term
    forall a. (Elims -> Term) -> ArgsCheckState a -> TCM Term
    checkHeadConstraints (Term
    u Term -> Elims -> Term
    forall t. Apply t => t -> Elims -> t
    `applyE`) ArgsCheckState CheckedTarget
    st
                          Comparison -> CheckedTarget -> Term -> Type -> Type -> TCM Term
    coerce' Comparison
    cmp CheckedTarget
    targetCheck Term
    v Type
    trest Type
    tc

                  (Term, Type, CheckedTarget) -> TCM (Term, Type, CheckedTarget)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term
    v, Type
    tc, CheckedTarget
    NotCheckedTarget)

    refuseProj :: List1 QName -> String -> TCM a
    refuseProj :: forall a. List1 QName -> [Char] -> TCM a
    refuseProj List1 QName
    ds [Char]
    reason = TypeError -> TCMT IO a
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO a) -> TypeError -> TCMT IO a
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    GenericError ([Char] -> TypeError) -> [Char] -> TypeError
    forall a b. (a -> b) -> a -> b
    $
            [Char]
    "Cannot resolve overloaded projection "
            [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Name -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow (Name -> Name
    A.nameConcrete (Name -> Name) -> Name -> Name
    forall a b. (a -> b) -> a -> b
    $ QName -> Name
    A.qnameName (QName -> Name) -> QName -> Name
    forall a b. (a -> b) -> a -> b
    $ List1 QName -> QName
    forall a. NonEmpty a -> a
    List1.head List1 QName
    ds)
            [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    " because " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    reason

    refuseProjNotApplied, refuseProjNoMatching, refuseProjNotRecordType :: List1 QName -> TCM a
    refuseProjNotApplied :: forall a. List1 QName -> TCM a
    refuseProjNotApplied    List1 QName
    ds = List1 QName -> [Char] -> TCM a
    forall a. List1 QName -> [Char] -> TCM a
    refuseProj List1 QName
    ds [Char]
    "it is not applied to a visible argument"
    refuseProjNoMatching :: forall a. List1 QName -> TCM a
    refuseProjNoMatching    List1 QName
    ds = List1 QName -> [Char] -> TCM a
    forall a. List1 QName -> [Char] -> TCM a
    refuseProj List1 QName
    ds [Char]
    "no matching candidate found"
    refuseProjNotRecordType :: forall a. List1 QName -> TCM a
    refuseProjNotRecordType List1 QName
    ds = List1 QName -> [Char] -> TCM a
    forall a. List1 QName -> [Char] -> TCM a
    refuseProj List1 QName
    ds [Char]
    "principal argument is not of record type"

    -----------------------------------------------------------------------------
    -- * Sorts
    -----------------------------------------------------------------------------

    checkSet
      :: Comparison -> A.Expr -> Type
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkSet :: Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkSet = (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOrProp Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type

    checkProp
      :: Comparison -> A.Expr -> Type
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkProp :: Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkProp Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    s [NamedArg Expr]
    args = do
      TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    isPropEnabled (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    NeedOptionProp
      (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOrProp Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Prop Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    s [NamedArg Expr]
    args

    checkSSet
      :: Comparison -> A.Expr -> Type
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkSSet :: Comparison
    -> Expr -> Type -> QName -> Suffix -> [NamedArg Expr] -> TCM Term
    checkSSet Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    s [NamedArg Expr]
    args = do
      TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    isTwoLevelEnabled (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    NeedOptionTwoLevel
      (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkLeveledSort Level -> Sort' Term
    forall t. Level' t -> Sort' t
    SSet Level -> Sort' Term
    forall t. Level' t -> Sort' t
    SSet Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    s [NamedArg Expr]
    args

    checkSetOrProp
      :: (Level -> Sort) -> Comparison -> A.Expr -> Type
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkSetOrProp :: (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOrProp Level -> Sort' Term
    mkSort Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    suffix [NamedArg Expr]
    args = do
      (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkLeveledSort Level -> Sort' Term
    mkSort Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    suffix [NamedArg Expr]
    args

    checkLeveledSort
      :: (Level -> Sort) -> (Level -> Sort) -> Comparison -> A.Expr -> Type
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkLeveledSort :: (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Comparison
    -> Expr
    -> Type
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkLeveledSort Level -> Sort' Term
    mkSort Level -> Sort' Term
    mkSortOfSort Comparison
    cmp Expr
    e Type
    t QName
    q Suffix
    suffix [NamedArg Expr]
    args = do
      (Term
    v, Type
    t0) <- (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Expr
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferLeveledSort Level -> Sort' Term
    mkSort Level -> Sort' Term
    mkSortOfSort Expr
    e QName
    q Suffix
    suffix [NamedArg Expr]
    args
      Comparison -> Term -> Type -> Type -> TCM Term
    forall (m :: * -> *).
    (MonadConversion m, MonadTCM m) =>
    Comparison -> Term -> Type -> Type -> m Term
    coerce Comparison
    cmp Term
    v Type
    t0 Type
    t

    inferSet :: A.Expr -> QName -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferSet :: Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSet = (Level -> Sort' Term)
    -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSetOrProp Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type

    inferProp :: A.Expr -> QName -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferProp :: Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferProp Expr
    e QName
    q Suffix
    s [NamedArg Expr]
    args = do
      TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    isPropEnabled (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    NeedOptionProp
      (Level -> Sort' Term)
    -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSetOrProp Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Prop Expr
    e QName
    q Suffix
    s [NamedArg Expr]
    args

    inferSSet :: A.Expr -> QName -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferSSet :: Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSSet Expr
    e QName
    q Suffix
    s [NamedArg Expr]
    args = do
      TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    isTwoLevelEnabled (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    NeedOptionTwoLevel
      (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Expr
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferLeveledSort Level -> Sort' Term
    forall t. Level' t -> Sort' t
    SSet Level -> Sort' Term
    forall t. Level' t -> Sort' t
    SSet Expr
    e QName
    q Suffix
    s [NamedArg Expr]
    args

    inferSetOrProp
      :: (Level -> Sort) -> A.Expr
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferSetOrProp :: (Level -> Sort' Term)
    -> Expr -> QName -> Suffix -> [NamedArg Expr] -> TCM (Term, Type)
    inferSetOrProp Level -> Sort' Term
    mkSort Expr
    e QName
    q Suffix
    suffix [NamedArg Expr]
    args = (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Expr
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferLeveledSort Level -> Sort' Term
    mkSort Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type Expr
    e QName
    q Suffix
    suffix [NamedArg Expr]
    args

    inferLeveledSort
      :: (Level -> Sort) -> (Level -> Sort) -> A.Expr
      -> QName -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferLeveledSort :: (Level -> Sort' Term)
    -> (Level -> Sort' Term)
    -> Expr
    -> QName
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferLeveledSort Level -> Sort' Term
    mkSort Level -> Sort' Term
    mkSortOfSort Expr
    e QName
    q Suffix
    suffix [NamedArg Expr]
    args = case [NamedArg Expr]
    args of
      [] -> do
        let n :: Integer
    n = case Suffix
    suffix of
                  Suffix
    NoSuffix -> Integer
    0
                  Suffix Integer
    n -> Integer
    n
        (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort' Term -> Term
    Sort (Level -> Sort' Term
    mkSort (Level -> Sort' Term) -> Level -> Sort' Term
    forall a b. (a -> b) -> a -> b
    $ Integer -> Level
    ClosedLevel Integer
    n) , Sort' Term -> Type
    sort (Level -> Sort' Term
    mkSortOfSort (Level -> Sort' Term) -> Level -> Sort' Term
    forall a b. (a -> b) -> a -> b
    $ Integer -> Level
    ClosedLevel (Integer -> Level) -> Integer -> Level
    forall a b. (a -> b) -> a -> b
    $ Integer
    n Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    + Integer
    1))
      [NamedArg Expr
    arg] -> do
        Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    unless (NamedArg Expr -> Bool
    forall a. LensHiding a => a -> Bool
    visible NamedArg Expr
    arg) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO ()) -> TypeError -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ Type -> TypeError
    WrongHidingInApplication (Type -> TypeError) -> Type -> TypeError
    forall a b. (a -> b) -> a -> b
    $ Sort' Term -> Type
    sort (Sort' Term -> Type) -> Sort' Term -> Type
    forall a b. (a -> b) -> a -> b
    $ Level -> Sort' Term
    mkSort (Level -> Sort' Term) -> Level -> Sort' Term
    forall a b. (a -> b) -> a -> b
    $ Integer -> Level
    ClosedLevel Integer
    0
        TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    hasUniversePolymorphism (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    [Char] -> m a
    genericError
          [Char]
    "Use --universe-polymorphism to enable level arguments to Set"
        Level
    l <- Relevance -> TCMT IO Level -> TCMT IO Level
    forall (tcm :: * -> *) r a.
    (MonadTCEnv tcm, LensRelevance r) =>
    r -> tcm a -> tcm a
    applyRelevanceToContext Relevance
    NonStrict (TCMT IO Level -> TCMT IO Level) -> TCMT IO Level -> TCMT IO Level
    forall a b. (a -> b) -> a -> b
    $ NamedArg Expr -> TCMT IO Level
    checkLevel NamedArg Expr
    arg
        (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort' Term -> Term
    Sort (Sort' Term -> Term) -> Sort' Term -> Term
    forall a b. (a -> b) -> a -> b
    $ Level -> Sort' Term
    mkSort Level
    l , Sort' Term -> Type
    sort (Level -> Sort' Term
    mkSortOfSort (Level -> Sort' Term) -> Level -> Sort' Term
    forall a b. (a -> b) -> a -> b
    $ Level -> Level
    levelSuc Level
    l))
      NamedArg Expr
    arg : [NamedArg Expr]
    _ -> TypeError -> TCM (Term, Type)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (Term, Type))
    -> (Doc -> TypeError) -> Doc -> TCM (Term, Type)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCM (Term, Type)) -> TCMT IO Doc -> TCM (Term, Type)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    fsep
        [ QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    q , TCMT IO Doc
    "cannot be applied to more than one argument" ]

    checkSetOmega :: Comparison -> A.Expr -> Type -> QName -> IsFibrant -> Suffix -> [NamedArg A.Expr] -> TCM Term
    checkSetOmega :: Comparison
    -> Expr
    -> Type
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM Term
    checkSetOmega Comparison
    cmp Expr
    e Type
    t QName
    q IsFibrant
    f Suffix
    s [NamedArg Expr]
    args = do
      (Term
    v, Type
    t0) <- Expr
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferSetOmega Expr
    e QName
    q IsFibrant
    f Suffix
    s [NamedArg Expr]
    args
      Comparison -> Term -> Type -> Type -> TCM Term
    forall (m :: * -> *).
    (MonadConversion m, MonadTCM m) =>
    Comparison -> Term -> Type -> Type -> m Term
    coerce Comparison
    cmp Term
    v Type
    t0 Type
    t

    inferSetOmega :: A.Expr -> QName -> IsFibrant -> Suffix -> [NamedArg A.Expr] -> TCM (Term, Type)
    inferSetOmega :: Expr
    -> QName
    -> IsFibrant
    -> Suffix
    -> [NamedArg Expr]
    -> TCM (Term, Type)
    inferSetOmega Expr
    e QName
    q IsFibrant
    f Suffix
    suffix [NamedArg Expr]
    args = do
      Bool -> TCMT IO () -> TCMT IO ()
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
    when (IsFibrant
    f IsFibrant -> IsFibrant -> Bool
    forall a. Eq a => a -> a -> Bool
    == IsFibrant
    IsStrict) (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $
        TCMT IO Bool -> TCMT IO () -> TCMT IO ()
    forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
    unlessM TCMT IO Bool
    forall (m :: * -> *). HasOptions m => m Bool
    isTwoLevelEnabled (TCMT IO () -> TCMT IO ()) -> TCMT IO () -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ TypeError -> TCMT IO ()
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError TypeError
    NeedOptionTwoLevel
      let n :: Integer
    n = case Suffix
    suffix of
                Suffix
    NoSuffix -> Integer
    0
                Suffix Integer
    n -> Integer
    n
      case [NamedArg Expr]
    args of
        [] -> (Term, Type) -> TCM (Term, Type)
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Sort' Term -> Term
    Sort (IsFibrant -> Integer -> Sort' Term
    forall t. IsFibrant -> Integer -> Sort' t
    Inf IsFibrant
    f Integer
    n) , Sort' Term -> Type
    sort (IsFibrant -> Integer -> Sort' Term
    forall t. IsFibrant -> Integer -> Sort' t
    Inf IsFibrant
    f (Integer -> Sort' Term) -> Integer -> Sort' Term
    forall a b. (a -> b) -> a -> b
    $ Integer
    1 Integer -> Integer -> Integer
    forall a. Num a => a -> a -> a
    + Integer
    n))
        NamedArg Expr
    arg : [NamedArg Expr]
    _ -> TypeError -> TCM (Term, Type)
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCM (Term, Type))
    -> (Doc -> TypeError) -> Doc -> TCM (Term, Type)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCM (Term, Type)) -> TCMT IO Doc -> TCM (Term, Type)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    fsep
            [ QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    q , TCMT IO Doc
    "cannot be applied to an argument" ]

    -----------------------------------------------------------------------------
    -- * Coinduction
    -----------------------------------------------------------------------------

    checkSharpApplication :: A.Expr -> Type -> QName -> [NamedArg A.Expr] -> TCM Term
    checkSharpApplication :: Expr -> Type -> QName -> [NamedArg Expr] -> TCM Term
    checkSharpApplication Expr
    e Type
    t QName
    c [NamedArg Expr]
    args = do
      Expr
    arg <- case [NamedArg Expr]
    args of
               [NamedArg Expr
    a] | NamedArg Expr -> Bool
    forall a. LensHiding a => a -> Bool
    visible NamedArg Expr
    a -> Expr -> TCMT IO Expr
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Expr -> TCMT IO Expr) -> Expr -> TCMT IO Expr
    forall a b. (a -> b) -> a -> b
    $ NamedArg Expr -> Expr
    forall a. NamedArg a -> a
    namedArg NamedArg Expr
    a
               [NamedArg Expr]
    _ -> TypeError -> TCMT IO Expr
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Expr) -> TypeError -> TCMT IO Expr
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TypeError
    GenericError ([Char] -> TypeError) -> [Char] -> TypeError
    forall a b. (a -> b) -> a -> b
    $ QName -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow QName
    c [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    " must be applied to exactly one argument."

      -- The name of the fresh function.
      Nat
    i <- TCMT IO Nat
    forall i (m :: * -> *). MonadFresh i m => m i
    fresh :: TCM Int
      let name :: [Char]
    name = (Char -> Bool) -> [Char] -> [Char]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Char
    '_') (Name -> [Char]
    forall a. Pretty a => a -> [Char]
    prettyShow (Name -> [Char]) -> Name -> [Char]
    forall a b. (a -> b) -> a -> b
    $ Name -> Name
    A.nameConcrete (Name -> Name) -> Name -> Name
    forall a b. (a -> b) -> a -> b
    $ QName -> Name
    A.qnameName QName
    c) [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    "-" [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Nat -> [Char]
    forall a. Show a => a -> [Char]
    show Nat
    i

      CoinductionKit
    kit <- TCM CoinductionKit
    coinductionKit'
      let flat :: QName
    flat = CoinductionKit -> QName
    nameOfFlat CoinductionKit
    kit
          inf :: QName
    inf  = CoinductionKit -> QName
    nameOfInf  CoinductionKit
    kit

      -- Add the type signature of the fresh function to the
      -- signature.
      -- To make sure we can type check the generated function we have to make
      -- sure that its type is \inf. The reason for this is that we don't yet
      -- postpone checking of patterns when we don't know their types (Issue480).
      Type
    forcedType <- do
        Type
    lvl <- TCMT IO Type
    forall (m :: * -> *). HasBuiltins m => m Type
    levelType
        (MetaId
    _, Term
    l) <- RunMetaOccursCheck -> Comparison -> Type -> TCMT IO (MetaId, Term)
    forall (m :: * -> *).
    MonadMetaSolver m =>
    RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term)
    newValueMeta RunMetaOccursCheck
    RunMetaOccursCheck Comparison
    CmpLeq Type
    lvl
        Level
    lv  <- Term -> TCMT IO Level
    forall (m :: * -> *). PureTCM m => Term -> m Level
    levelView Term
    l
        (MetaId
    _, Term
    a) <- RunMetaOccursCheck -> Comparison -> Type -> TCMT IO (MetaId, Term)
    forall (m :: * -> *).
    MonadMetaSolver m =>
    RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term)
    newValueMeta RunMetaOccursCheck
    RunMetaOccursCheck Comparison
    CmpEq (Sort' Term -> Type
    sort (Sort' Term -> Type) -> Sort' Term -> Type
    forall a b. (a -> b) -> a -> b
    $ Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type Level
    lv)
        Type -> TCMT IO Type
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Type -> TCMT IO Type) -> Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ Sort' Term -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El (Level -> Sort' Term
    forall t. Level' t -> Sort' t
    Type Level
    lv) (Term -> Type) -> Term -> Type
    forall a b. (a -> b) -> a -> b
    $ QName -> Elims -> Term
    Def QName
    inf [Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Arg Term -> Elim) -> Arg Term -> Elim
    forall a b. (a -> b) -> a -> b
    $ Hiding -> Arg Term -> Arg Term
    forall a. LensHiding a => Hiding -> a -> a
    setHiding Hiding
    Hidden (Arg Term -> Arg Term) -> Arg Term -> Arg Term
    forall a b. (a -> b) -> a -> b
    $ Term -> Arg Term
    forall e. e -> Arg e
    defaultArg Term
    l, Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Arg Term -> Elim) -> Arg Term -> Elim
    forall a b. (a -> b) -> a -> b
    $ Term -> Arg Term
    forall e. e -> Arg e
    defaultArg Term
    a]

      QName
    wrapper <- TCM QName -> TCM QName
    forall a. TCM a -> TCM a
    inFreshModuleIfFreeParams (TCM QName -> TCM QName) -> TCM QName -> TCM QName
    forall a b. (a -> b) -> a -> b
    $ (TCEnv -> TCEnv) -> TCM QName -> TCM QName
    forall (m :: * -> *) a.
    MonadTCEnv m =>
    (TCEnv -> TCEnv) -> m a -> m a
    localTC (Lens' Quantity TCEnv -> LensSet Quantity TCEnv
    forall i o. Lens' i o -> LensSet i o
    set Lens' Quantity TCEnv
    eQuantity Quantity
    topQuantity) (TCM QName -> TCM QName) -> TCM QName -> TCM QName
    forall a b. (a -> b) -> a -> b
    $ do
        -- Andreas, 2019-10-12: create helper functions in non-erased mode.
        -- Otherwise, they are not usable in meta-solutions in the term world.
        QName
    c' <- Range -> QName -> QName
    forall a. SetRange a => Range -> a -> a
    setRange (QName -> Range
    forall a. HasRange a => a -> Range
    getRange QName
    c) (QName -> QName) -> TCM QName -> TCM QName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
                (ModuleName -> Name -> QName)
    -> TCMT IO ModuleName -> TCMT IO Name -> TCM QName
    forall (m :: * -> *) a1 a2 r.
    Monad m =>
    (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
    liftM2 ModuleName -> Name -> QName
    qualify (KillRangeT ModuleName
    forall a. KillRange a => KillRangeT a
    killRange KillRangeT ModuleName -> TCMT IO ModuleName -> TCMT IO ModuleName
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO ModuleName
    forall (m :: * -> *). MonadTCEnv m => m ModuleName
    currentModule)
                               ([Char] -> TCMT IO Name
    forall a (m :: * -> *).
    (FreshName a, MonadFresh NameId m) =>
    a -> m Name
    freshName_ [Char]
    name)

        -- Define and type check the fresh function.
        Modality
    mod <- (TCEnv -> Modality) -> TCMT IO Modality
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC TCEnv -> Modality
    forall a. LensModality a => a -> Modality
    getModality
        IsAbstract
    abs <- (TCEnv -> IsAbstract) -> TCMT IO IsAbstract
    forall (m :: * -> *) a. MonadTCEnv m => (TCEnv -> a) -> m a
    asksTC (TCEnv -> Lens' IsAbstract TCEnv -> IsAbstract
    forall o i. o -> Lens' i o -> i
    ^. forall a. LensIsAbstract a => Lens' IsAbstract a
    Lens' IsAbstract TCEnv
    lensIsAbstract)
        let info :: DefInfo' Expr
    info   = Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' Expr
    forall t.
    Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t
    A.mkDefInfo (Name -> Name
    A.nameConcrete (Name -> Name) -> Name -> Name
    forall a b. (a -> b) -> a -> b
    $ QName -> Name
    A.qnameName QName
    c') Fixity'
    noFixity'
                                 Access
    PublicAccess IsAbstract
    abs Range
    forall a. Range' a
    noRange
            core :: LHSCore' Expr
    core   = LHSProj :: forall e.
    AmbiguousQName
    -> NamedArg (LHSCore' e) -> [NamedArg (Pattern' e)] -> LHSCore' e
    A.LHSProj { lhsDestructor :: AmbiguousQName
    A.lhsDestructor = QName -> AmbiguousQName
    unambiguous QName
    flat
                               , lhsFocus :: NamedArg (LHSCore' Expr)
    A.lhsFocus      = LHSCore' Expr -> NamedArg (LHSCore' Expr)
    forall a. a -> NamedArg a
    defaultNamedArg (LHSCore' Expr -> NamedArg (LHSCore' Expr))
    -> LHSCore' Expr -> NamedArg (LHSCore' Expr)
    forall a b. (a -> b) -> a -> b
    $ QName -> [NamedArg (Pattern' Expr)] -> LHSCore' Expr
    forall e. QName -> [NamedArg (Pattern' e)] -> LHSCore' e
    A.LHSHead QName
    c' []
                               , lhsPats :: [NamedArg (Pattern' Expr)]
    A.lhsPats       = [] }
            clause :: Clause' LHS
    clause = LHS
    -> [ProblemEq] -> RHS -> WhereDeclarations -> Bool -> Clause' LHS
    forall lhs.
    lhs
    -> [ProblemEq] -> RHS -> WhereDeclarations -> Bool -> Clause' lhs
    A.Clause (LHSInfo -> LHSCore' Expr -> LHS
    A.LHS LHSInfo
    forall a. Null a => a
    empty LHSCore' Expr
    core) []
                              (Expr -> Maybe Expr -> RHS
    A.RHS Expr
    arg Maybe Expr
    forall a. Maybe a
    Nothing)
                              WhereDeclarations
    A.noWhereDecls Bool
    False

        MutualId
    i <- TCM MutualId
    currentOrFreshMutualBlock

        -- If we are in irrelevant position, add definition irrelevantly.
        -- If we are in erased position, add definition as erased.
        -- TODO: is this sufficient?
        QName -> Definition -> TCMT IO ()
    addConstant QName
    c' (Definition -> TCMT IO ()) -> TCMT IO Definition -> TCMT IO ()
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< do
          let ai :: ArgInfo
    ai = Modality -> ArgInfo -> ArgInfo
    forall a. LensModality a => Modality -> a -> a
    setModality Modality
    mod ArgInfo
    defaultArgInfo
          Language
    lang <- TCMT IO Language
    forall (m :: * -> *). HasOptions m => m Language
    getLanguage
          Definition -> TCMT IO Definition
    useTerPragma (Definition -> TCMT IO Definition)
    -> Definition -> TCMT IO Definition
    forall a b. (a -> b) -> a -> b
    $
            (ArgInfo -> QName -> Type -> Language -> Defn -> Definition
    defaultDefn ArgInfo
    ai QName
    c' Type
    forcedType Language
    lang Defn
    emptyFunction)
            { defMutual :: MutualId
    defMutual = MutualId
    i }

        Delayed -> DefInfo' Expr -> QName -> [Clause' LHS] -> TCMT IO ()
    checkFunDef Delayed
    NotDelayed DefInfo' Expr
    info QName
    c' [Clause' LHS
    clause]

        [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.expr.coind" Nat
    15 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ do
          Defn
    def <- Definition -> Defn
    theDef (Definition -> Defn) -> TCMT IO Definition -> TCMT IO Defn
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> QName -> TCMT IO Definition
    forall (m :: * -> *). HasConstInfo m => QName -> m Definition
    getConstInfo QName
    c'
          [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat ([TCMT IO Doc] -> TCMT IO Doc) -> [TCMT IO Doc] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $
            [ TCMT IO Doc
    "The coinductive wrapper"
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Modality -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Modality
    mod TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall a. Semigroup a => a -> a -> a
    <> (QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c' TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    ":")
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    4 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Type -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Type
    t
            , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Clause' LHS -> TCMT IO Doc
    forall a (m :: * -> *).
    (ToConcrete a, Pretty (ConOfAbs a), MonadAbsToCon m) =>
    a -> m Doc
    prettyA Clause' LHS
    clause
            , (TCMT IO Doc
    "The definition is" TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Delayed -> [Char]
    forall a. Show a => a -> [Char]
    show (Delayed -> [Char]) -> Delayed -> [Char]
    forall a b. (a -> b) -> a -> b
    $ Defn -> Delayed
    funDelayed Defn
    def)) TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall a. Semigroup a => a -> a -> a
    <>
              TCMT IO Doc
    "."
            ]
        QName -> TCM QName
    forall (m :: * -> *) a. Monad m => a -> m a
    return QName
    c'

      -- The application of the fresh function to the relevant
      -- arguments.
      Term
    e' <- QName -> Elims -> Term
    Def QName
    wrapper (Elims -> Term) -> (Args -> Elims) -> Args -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Arg Term -> Elim) -> Args -> Elims
    forall a b. (a -> b) -> [a] -> [b]
    map Arg Term -> Elim
    forall a. Arg a -> Elim' a
    Apply (Args -> Term) -> TCMT IO Args -> TCM Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> TCMT IO Args
    forall (m :: * -> *). (Applicative m, MonadTCEnv m) => m Args
    getContextArgs

      [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.expr.coind" Nat
    15 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [TCMT IO Doc] -> TCMT IO Doc
    forall (m :: * -> *) (t :: * -> *).
    (Applicative m, Foldable t) =>
    t (m Doc) -> m Doc
    vcat ([TCMT IO Doc] -> TCMT IO Doc) -> [TCMT IO Doc] -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $
          [ TCMT IO Doc
    "The coinductive constructor application"
          , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Expr -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Expr
    e
          , TCMT IO Doc
    "was translated into the application"
          , Nat -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Functor m => Nat -> m Doc -> m Doc
    nest Nat
    2 (TCMT IO Doc -> TCMT IO Doc) -> TCMT IO Doc -> TCMT IO Doc
    forall a b. (a -> b) -> a -> b
    $ Term -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM Term
    e'
          ]

      Type -> TCM Term -> TCM Term
    forall (m :: * -> *).
    (MonadMetaSolver m, MonadConstraint m, MonadFresh Nat m,
     MonadFresh ProblemId m) =>
    Type -> m Term -> m Term
    blockTerm Type
    t (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Term
    e' Term -> TCMT IO () -> TCM Term
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ TCMT IO () -> TCMT IO ()
    forall (m :: * -> *) a.
    (MonadTCEnv m, HasOptions m, MonadDebug m) =>
    m a -> m a
    workOnTypes (Type -> Type -> TCMT IO ()
    forall (m :: * -> *). MonadConversion m => Type -> Type -> m ()
    leqType Type
    forcedType Type
    t)

    -----------------------------------------------------------------------------
    -- * Cubical
    -----------------------------------------------------------------------------

    -- | "pathAbs (PathView s _ l a x y) t" builds "(\ t) : pv"
    --   Preconditions: PathView is PathType, and t[i0] = x, t[i1] = y
    pathAbs :: PathView -> Abs Term -> TCM Term
    pathAbs :: PathView -> Abs Term -> TCM Term
    pathAbs (OType Type
    _) Abs Term
    t = TCM Term
    forall a. HasCallStack => a
    __IMPOSSIBLE__
    pathAbs (PathType Sort' Term
    s QName
    path Arg Term
    l Arg Term
    a Arg Term
    x Arg Term
    y) Abs Term
    t = do
      Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo Abs Term
    t

    -- | @primComp : ∀ {ℓ} (A : (i : I) → Set (ℓ i)) (φ : I) (u : ∀ i → Partial φ (A i)) (a : A i0) → A i1@
    --
    --   Check:  @u i0 = (λ _ → a) : Partial φ (A i0)@.
    --
    checkPrimComp :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    checkPrimComp :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimComp QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
        -- WAS: [l, a, phi, u, a0] -> do
        Arg Term
    l : Arg Term
    a : Arg Term
    phi : Arg Term
    u : Arg Term
    a0 : Args
    rest -> do
          Arg Term
    iz <- ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    defaultArgInfo (Term -> Arg Term) -> TCM Term -> TCMT IO (Arg Term)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IntervalView -> TCM Term
    forall (m :: * -> *). HasBuiltins m => IntervalView -> m Term
    intervalUnview IntervalView
    IZero
          let lz :: Term
    lz = Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Arg Term
    iz]
              az :: Term
    az = Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Arg Term
    iz]
          Type
    ty <- TCM Term -> TCM Term -> TCMT IO Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Arg Term
    iz])) (TCM Term -> TCMT IO Type) -> TCM Term -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPartial TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Arg Term
    iz]) TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    phi) TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    `apply` [Arg Term
    iz])
          Type
    bAz <- TCM Term -> TCM Term -> TCMT IO Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Term
    lz) (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Term
    az)
          Arg Term
    a0 <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    bAz (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    4) Arg Term
    a0 (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ do
            Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    ty -- (El (getSort t1) (apply (unArg a) [iz]))
              (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> Abs Term -> Term
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "_" (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a0)
              (Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    apply (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    u) [Arg Term
    iz])
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    l Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    u Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a0 Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
        Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    -- | @primHComp : ∀ {ℓ} {A : Set ℓ} {φ : I} (u : ∀ i → Partial φ A) (a : A) → A@
    --
    --   Check:  @u i0 = (λ _ → a) : Partial φ A@.
    --
    checkPrimHComp :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    checkPrimHComp :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimHComp QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
        -- WAS: [l, a, phi, u, a0] -> do
        Arg Term
    l : Arg Term
    a : Arg Term
    phi : Arg Term
    u : Arg Term
    a0 : Args
    rest -> do
          -- iz = i0
          Arg Term
    iz <- ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    defaultArgInfo (Term -> Arg Term) -> TCM Term -> TCMT IO (Arg Term)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IntervalView -> TCM Term
    forall (m :: * -> *). HasBuiltins m => IntervalView -> m Term
    intervalUnview IntervalView
    IZero
          -- ty = Partial φ A
          Type
    ty <- TCM Term -> TCM Term -> TCMT IO Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l)) (TCM Term -> TCMT IO Type) -> TCM Term -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPartial TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l) TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    phi) TCM Term -> TCM Term -> TCM Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)
          -- (λ _ → a) = u i0 : ty
          Type
    bA <- TCM Term -> TCM Term -> TCMT IO Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l) (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)
          Arg Term
    a0 <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    bA (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    4) Arg Term
    a0 (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ do
            Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    ty -- (El (getSort t1) (apply (unArg a) [iz]))
                (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> Abs Term -> Term
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "_" (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a0)
                (Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    apply (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    u) [Arg Term
    iz])
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    l Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    u Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a0 Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
        Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    -- | @transp : ∀{ℓ} (A : (i : I) → Set (ℓ i)) (φ : I) (a0 : A i0) → A i1@
    --
    --   Check:  If φ, then @A i = A i0 : Set (ℓ i)@ must hold for all @i : I@.
    --
    checkPrimTrans :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    checkPrimTrans :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPrimTrans QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
        -- Andreas, 2019-03-02, issue #3601, why exactly 4 arguments?
        -- Only 3 are needed to check the side condition.
        -- WAS:
        -- [l, a, phi, a0] -> do
        Arg Term
    l : Arg Term
    a : Arg Term
    phi : Args
    rest -> do
          Arg Term
    iz <- ArgInfo -> Term -> Arg Term
    forall e. ArgInfo -> e -> Arg e
    Arg ArgInfo
    defaultArgInfo (Term -> Arg Term) -> TCM Term -> TCMT IO (Arg Term)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> IntervalView -> TCM Term
    forall (m :: * -> *). HasBuiltins m => IntervalView -> m Term
    intervalUnview IntervalView
    IZero
          -- ty = (i : I) -> Set (l i)
          Type
    ty <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
            NamesT (TCMT IO) Term
    l <- Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    l
            [Char]
    -> NamesT (TCMT IO) Type
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadFail m, MonadAddContext m, MonadDebug m) =>
    [Char]
    -> NamesT m Type
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    nPi' [Char]
    "i" NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Type
    primIntervalType ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    i -> (Sort' Term -> Type
    sort (Sort' Term -> Type) -> (Term -> Sort' Term) -> Term -> Type
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort' Term
    tmSort (Term -> Type) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (NamesT (TCMT IO) Term
    l NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    i))
          Arg Term
    a <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    ty (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    1) Arg Term
    a (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ do
            Term -> Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Term -> Type -> Term -> Term -> m ()
    equalTermOnFace (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    phi) Type
    ty
              (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)
              (ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    defaultArgInfo (Abs Term -> Term) -> Abs Term -> Term
    forall a b. (a -> b) -> a -> b
    $ [Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "_" (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Term -> Args -> Term
    forall t. Apply t => t -> Args -> t
    apply (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a) [Arg Term
    iz])
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    l Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
        Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    blockArg :: HasRange r => Type -> r -> Arg Term -> TCM () -> TCM (Arg Term)
    blockArg :: forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    t r
    r Arg Term
    a TCMT IO ()
    m =
      Range -> TCMT IO (Arg Term) -> TCMT IO (Arg Term)
    forall (m :: * -> *) x a.
    (MonadTrace m, HasRange x) =>
    x -> m a -> m a
    setCurrentRange (r -> Range
    forall a. HasRange a => a -> Range
    getRange (r -> Range) -> r -> Range
    forall a b. (a -> b) -> a -> b
    $ r
    r) (TCMT IO (Arg Term) -> TCMT IO (Arg Term))
    -> TCMT IO (Arg Term) -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ (Term -> Arg Term) -> TCM Term -> TCMT IO (Arg Term)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (Arg Term
    a Arg Term -> Term -> Arg Term
    forall (f :: * -> *) a b. Functor f => f a -> b -> f b
    $>) (TCM Term -> TCMT IO (Arg Term)) -> TCM Term -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ Type -> TCM Term -> TCM Term
    forall (m :: * -> *).
    (MonadMetaSolver m, MonadConstraint m, MonadFresh Nat m,
     MonadFresh ProblemId m) =>
    Type -> m Term -> m Term
    blockTerm Type
    t (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ TCMT IO ()
    m TCMT IO () -> TCM Term -> TCM Term
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> Term -> TCM Term
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)

    checkConId :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    checkConId :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkConId QName
    c MaybeRanges
    rs Args
    vs Type
    t1 = do
      case Args
    vs of
       args :: Args
    args@[Arg Term
    _, Arg Term
    _, Arg Term
    _, Arg Term
    _, Arg Term
    phi, Arg Term
    p] -> do
          iv :: PathView
    iv@(PathType Sort' Term
    s QName
    _ Arg Term
    l Arg Term
    a Arg Term
    x Arg Term
    y) <- Type -> TCMT IO PathView
    forall (m :: * -> *). HasBuiltins m => Type -> m PathView
    idViewAsPath Type
    t1
          let ty :: Type
    ty = PathView -> Type
    pathUnview PathView
    iv
          -- the following duplicates reduction of phi
          Term
    const_x <- Type -> TCM Term -> TCM Term
    forall (m :: * -> *).
    (MonadMetaSolver m, MonadConstraint m, MonadFresh Nat m,
     MonadFresh ProblemId m) =>
    Type -> m Term -> m Term
    blockTerm Type
    ty (TCM Term -> TCM Term) -> TCM Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
              Term -> Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Term -> Type -> Term -> Term -> m ()
    equalTermOnFace (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    phi) (Sort' Term -> Term -> Type
    forall t a. Sort' t -> a -> Type'' t a
    El Sort' Term
    s (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)) (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    x) (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    y)
              PathView -> Abs Term -> TCM Term
    pathAbs PathView
    iv ([Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs ([Char] -> [Char]
    stringToArgName [Char]
    "_") (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    x))
          Arg Term
    p <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    ty (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    5) Arg Term
    p (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ do
            Term -> Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Term -> Type -> Term -> Term -> m ()
    equalTermOnFace (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    phi) Type
    ty (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    p) Term
    const_x   -- G, phi |- p = \ i . x
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Args -> Args -> Args
    forall a. [a] -> [a] -> [a]
    initWithDefault Args
    forall a. HasCallStack => a
    __IMPOSSIBLE__ Args
    args Args -> Args -> Args
    forall a. [a] -> [a] -> [a]
    ++ [Arg Term
    p]
          -- phi <- reduce phi
          -- forallFaceMaps (unArg phi) $ \ alpha -> do
          --   iv@(PathType s _ l a x y) <- idViewAsPath (applySubst alpha t1)
          --   let ty = pathUnview iv
          --   equalTerm (El s (unArg a)) (unArg x) (unArg y) -- precondition for cx being well-typed at ty
          --   cx <- pathAbs iv (NoAbs (stringToArgName "_") (applySubst alpha (unArg x)))
          --   equalTerm ty (applySubst alpha (unArg p)) cx   -- G, phi |- p = \ i . x
       Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    -- The following comment contains silly ' escapes to calm CPP about ∨ (\vee).
    -- May not be haddock-parseable.

    -- ' @primPOr : ∀ {ℓ} (φ₁ φ₂ : I) {A : Partial (φ₁ ∨ φ₂) (Set ℓ)}
    -- '         → (u : PartialP φ₁ (λ (o : IsOne φ₁) → A (IsOne1 φ₁ φ₂ o)))
    -- '         → (v : PartialP φ₂ (λ (o : IsOne φ₂) → A (IsOne2 φ₁ φ₂ o)))
    -- '         → PartialP (φ₁ ∨ φ₂) A@
    -- '
    -- ' Checks: @u = v : PartialP (φ₁ ∨ φ₂) A@ whenever @IsOne (φ₁ ∧ φ₂)@.
    checkPOr :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    checkPOr :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    checkPOr QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
       Arg Term
    l : Arg Term
    phi1 : Arg Term
    phi2 : Arg Term
    a : Arg Term
    u : Arg Term
    v : Args
    rest -> do
          Term
    phi <- IntervalView -> TCM Term
    forall (m :: * -> *). HasBuiltins m => IntervalView -> m Term
    intervalUnview (Arg Term -> Arg Term -> IntervalView
    IMin Arg Term
    phi1 Arg Term
    phi2)
          [Char] -> Nat -> TCMT IO Doc -> TCMT IO ()
    forall (m :: * -> *).
    MonadDebug m =>
    [Char] -> Nat -> TCMT IO Doc -> m ()
    reportSDoc [Char]
    "tc.term.por" Nat
    10 (TCMT IO Doc -> TCMT IO ()) -> TCMT IO Doc -> TCMT IO ()
    forall a b. (a -> b) -> a -> b
    $ [Char] -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => [Char] -> m Doc
    text (Term -> [Char]
    forall a. Show a => a -> [Char]
    show Term
    phi)
          -- phi <- reduce phi
          -- alphas <- toFaceMaps phi
          -- reportSDoc "tc.term.por" 10 $ text (show alphas)
          Type
    t1 <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
                 [NamesT (TCMT IO) Term
    l,NamesT (TCMT IO) Term
    a] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    l,Arg Term
    a]
                 NamesT (TCMT IO) Term
    psi <- Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< IntervalView -> NamesT (TCMT IO) Term
    forall (m :: * -> *). HasBuiltins m => IntervalView -> m Term
    intervalUnview (Arg Term -> Arg Term -> IntervalView
    IMax Arg Term
    phi1 Arg Term
    phi2)
                 [Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" NamesT (TCMT IO) Term
    psi ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    l (NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o)
          Type
    tv <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
                 [NamesT (TCMT IO) Term
    l,NamesT (TCMT IO) Term
    a,NamesT (TCMT IO) Term
    phi1,NamesT (TCMT IO) Term
    phi2] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    l,Arg Term
    a,Arg Term
    phi1,Arg Term
    phi2]
                 [Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" NamesT (TCMT IO) Term
    phi2 ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    l (NamesT (TCMT IO) Term
    a NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> (TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIsOne2 NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi1 NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi2 NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    o))
          Arg Term
    v <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    tv (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    5) Arg Term
    v (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ do
            -- ' φ₁ ∧ φ₂  ⊢ u , v : PartialP (φ₁ ∨ φ₂) \ o → a o
            Term -> Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Term -> Type -> Term -> Term -> m ()
    equalTermOnFace Term
    phi Type
    t1 (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    u) (Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    v)
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    l Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi1 Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi2 Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    u Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    v Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
       Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    -- | @prim^glue : ∀ {ℓ ℓ'} {A : Set ℓ} {φ : I}
    --              → {T : Partial φ (Set ℓ')} → {e : PartialP φ (λ o → T o ≃ A)}
    --              → (t : PartialP φ T) → (a : A) → primGlue A T e@
    --
    --   Check   @φ ⊢ a = e 1=1 (t 1=1)@  or actually the equivalent:  @(\ _ → a) = (\ o -> e o (t o)) : PartialP φ A@
    check_glue :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    check_glue :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    check_glue QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
       -- WAS: [la, lb, bA, phi, bT, e, t, a] -> do
       Arg Term
    la : Arg Term
    lb : Arg Term
    bA : Arg Term
    phi : Arg Term
    bT : Arg Term
    e : Arg Term
    t : Arg Term
    a : Args
    rest -> do
          let iinfo :: ArgInfo
    iinfo = Relevance -> ArgInfo -> ArgInfo
    forall a. LensRelevance a => Relevance -> a -> a
    setRelevance Relevance
    Irrelevant ArgInfo
    defaultArgInfo
          Term
    v <- [[Char]] -> NamesT (TCMT IO) Term -> TCM Term
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Term -> TCM Term)
    -> NamesT (TCMT IO) Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
                [NamesT (TCMT IO) Term
    lb, NamesT (TCMT IO) Term
    la, NamesT (TCMT IO) Term
    bA, NamesT (TCMT IO) Term
    phi, NamesT (TCMT IO) Term
    bT, NamesT (TCMT IO) Term
    e, NamesT (TCMT IO) Term
    t] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    lb, Arg Term
    la, Arg Term
    bA, Arg Term
    phi, Arg Term
    bT, Arg Term
    e, Arg Term
    t]
                let f :: NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    o = TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primEquivFun NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    la NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> (NamesT (TCMT IO) Term
    bT NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    bA NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    e NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o)
                ArgInfo
    -> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    MonadFail m =>
    ArgInfo
    -> [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    glam ArgInfo
    iinfo [Char]
    "o" ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
     -> NamesT (TCMT IO) Term)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    o NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    t NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o)
          Type
    ty <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
                [NamesT (TCMT IO) Term
    lb, NamesT (TCMT IO) Term
    phi, NamesT (TCMT IO) Term
    bA] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    lb, Arg Term
    phi, Arg Term
    bA]
                NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el's NamesT (TCMT IO) Term
    lb (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primPartialP NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    lb NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> ArgInfo
    -> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    MonadFail m =>
    ArgInfo
    -> [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    glam ArgInfo
    iinfo [Char]
    "o" (\ NamesT (TCMT IO) Term
    _ -> NamesT (TCMT IO) Term
    bA)
          let a' :: Term
    a' = ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    iinfo ([Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "o" (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)
          Type
    ta <- TCM Term -> TCM Term -> TCMT IO Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    la) (Term -> TCM Term
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Term -> TCM Term) -> Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    bA)
          Arg Term
    a <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    ta (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    7) Arg Term
    a (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    ty Term
    a' Term
    v
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    la Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    lb Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    bA Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    bT Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    e Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    t Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
       Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"

    -- | @prim^glueU : ∀ {ℓ} {φ : I}
    --              → {T : I → Partial φ (Set ℓ)} → {A : Set ℓ [ φ ↦ T i0 ]}
    --              → (t : PartialP φ (T i1)) → (a : outS A) → hcomp T (outS A)@
    --
    --   Check   @φ ⊢ a = transp (\ i -> T 1=1 (~ i)) i0 (t 1=1)@  or actually the equivalent:
    --           @(\ _ → a) = (\o -> transp (\ i -> T o (~ i)) i0 (t o)) : PartialP φ (T i0)@
    check_glueU :: QName -> MaybeRanges -> Args -> Type -> TCM Args
    check_glueU :: QName -> MaybeRanges -> Args -> Type -> TCMT IO Args
    check_glueU QName
    c MaybeRanges
    rs Args
    vs Type
    _ = do
      case Args
    vs of
       -- WAS: [la, lb, bA, phi, bT, e, t, a] -> do
       Arg Term
    la : Arg Term
    phi : Arg Term
    bT : Arg Term
    bA : Arg Term
    t : Arg Term
    a : Args
    rest -> do
          let iinfo :: ArgInfo
    iinfo = Relevance -> ArgInfo -> ArgInfo
    forall a. LensRelevance a => Relevance -> a -> a
    setRelevance Relevance
    Irrelevant ArgInfo
    defaultArgInfo
          Term
    v <- [[Char]] -> NamesT (TCMT IO) Term -> TCM Term
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Term -> TCM Term)
    -> NamesT (TCMT IO) Term -> TCM Term
    forall a b. (a -> b) -> a -> b
    $ do
                [NamesT (TCMT IO) Term
    la, NamesT (TCMT IO) Term
    phi, NamesT (TCMT IO) Term
    bT, NamesT (TCMT IO) Term
    bA, NamesT (TCMT IO) Term
    t] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    la, Arg Term
    phi, Arg Term
    bT, Arg Term
    bA, Arg Term
    t]
                let f :: NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    o = TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primTrans NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    MonadFail m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "i" (NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall a b. a -> b -> a
    const NamesT (TCMT IO) Term
    la) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    MonadFail m =>
    [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    lam [Char]
    "i" (\ NamesT (TCMT IO) Term
    i -> NamesT (TCMT IO) Term
    bT NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primINeg NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    i) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero
                ArgInfo
    -> [Char]
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall (m :: * -> *).
    MonadFail m =>
    ArgInfo
    -> [Char] -> (NamesT m Term -> NamesT m Term) -> NamesT m Term
    glam ArgInfo
    iinfo [Char]
    "o" ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
     -> NamesT (TCMT IO) Term)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term)
    -> NamesT (TCMT IO) Term
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    f NamesT (TCMT IO) Term
    o NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> (NamesT (TCMT IO) Term
    t NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o)
          Type
    ty <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
                [NamesT (TCMT IO) Term
    la, NamesT (TCMT IO) Term
    phi, NamesT (TCMT IO) Term
    bT] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    la, Arg Term
    phi, Arg Term
    bT]
                [Char]
    -> NamesT (TCMT IO) Term
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall (m :: * -> *).
    (MonadAddContext m, HasBuiltins m, MonadDebug m) =>
    [Char]
    -> NamesT m Term
    -> (NamesT m Term -> NamesT m Type)
    -> NamesT m Type
    pPi' [Char]
    "o" NamesT (TCMT IO) Term
    phi ((NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
     -> NamesT (TCMT IO) Type)
    -> (NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type)
    -> NamesT (TCMT IO) Type
    forall a b. (a -> b) -> a -> b
    $ \ NamesT (TCMT IO) Term
    o -> NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    la (NamesT (TCMT IO) Term
    bT NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <..> NamesT (TCMT IO) Term
    o)
          let a' :: Term
    a' = ArgInfo -> Abs Term -> Term
    Lam ArgInfo
    iinfo ([Char] -> Term -> Abs Term
    forall a. [Char] -> a -> Abs a
    NoAbs [Char]
    "o" (Term -> Abs Term) -> Term -> Abs Term
    forall a b. (a -> b) -> a -> b
    $ Arg Term -> Term
    forall e. Arg e -> e
    unArg Arg Term
    a)
          Type
    ta <- [[Char]] -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall (m :: * -> *) a. [[Char]] -> NamesT m a -> m a
    runNamesT [] (NamesT (TCMT IO) Type -> TCMT IO Type)
    -> NamesT (TCMT IO) Type -> TCMT IO Type
    forall a b. (a -> b) -> a -> b
    $ do
                [NamesT (TCMT IO) Term
    la, NamesT (TCMT IO) Term
    phi, NamesT (TCMT IO) Term
    bT, NamesT (TCMT IO) Term
    bA] <- (Arg Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> Args -> NamesT (TCMT IO) [NamesT (TCMT IO) Term]
    forall (t :: * -> *) (m :: * -> *) a b.
    (Traversable t, Monad m) =>
    (a -> m b) -> t a -> m (t b)
    mapM (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall (m :: * -> *) a.
    (MonadFail m, Subst a) =>
    a -> NamesT m (NamesT m a)
    open (Term -> NamesT (TCMT IO) (NamesT (TCMT IO) Term))
    -> (Arg Term -> Term)
    -> Arg Term
    -> NamesT (TCMT IO) (NamesT (TCMT IO) Term)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Arg Term -> Term
    forall e. Arg e -> e
    unArg) [Arg Term
    la, Arg Term
    phi, Arg Term
    bT, Arg Term
    bA]
                NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Type
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Type
    el' NamesT (TCMT IO) Term
    la (TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primSubOut NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> (TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primLevelSuc NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    la) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> (Sort' Term -> Term
    Sort (Sort' Term -> Term) -> (Term -> Sort' Term) -> Term -> Term
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Term -> Sort' Term
    tmSort (Term -> Term) -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamesT (TCMT IO) Term
    la) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> NamesT (TCMT IO) Term
    phi NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <#> (NamesT (TCMT IO) Term
    bT NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> TCM Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *) a. Monad m => m a -> NamesT m a
    cl TCM Term
    forall (m :: * -> *).
    (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) =>
    m Term
    primIZero) NamesT (TCMT IO) Term
    -> NamesT (TCMT IO) Term -> NamesT (TCMT IO) Term
    forall (m :: * -> *). Applicative m => m Term -> m Term -> m Term
    <@> NamesT (TCMT IO) Term
    bA)
          Arg Term
    a <- Type
    -> Maybe (Maybe Range)
    -> Arg Term
    -> TCMT IO ()
    -> TCMT IO (Arg Term)
    forall r.
    HasRange r =>
    Type -> r -> Arg Term -> TCMT IO () -> TCMT IO (Arg Term)
    blockArg Type
    ta (MaybeRanges
    rs MaybeRanges -> Nat -> Maybe (Maybe Range)
    forall a. [a] -> Nat -> Maybe a
    !!! Nat
    5) Arg Term
    a (TCMT IO () -> TCMT IO (Arg Term))
    -> TCMT IO () -> TCMT IO (Arg Term)
    forall a b. (a -> b) -> a -> b
    $ Type -> Term -> Term -> TCMT IO ()
    forall (m :: * -> *).
    MonadConversion m =>
    Type -> Term -> Term -> m ()
    equalTerm Type
    ty Term
    a' Term
    v
          Args -> TCMT IO Args
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Args -> TCMT IO Args) -> Args -> TCMT IO Args
    forall a b. (a -> b) -> a -> b
    $ Arg Term
    la Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    phi Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    bT Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    bA Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    t Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Arg Term
    a Arg Term -> Args -> Args
    forall a. a -> [a] -> [a]
    : Args
    rest
       Args
    _ -> TypeError -> TCMT IO Args
    forall (m :: * -> *) a.
    (HasCallStack, MonadTCError m) =>
    TypeError -> m a
    typeError (TypeError -> TCMT IO Args)
    -> (Doc -> TypeError) -> Doc -> TCMT IO Args
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Doc -> TypeError
    GenericDocError (Doc -> TCMT IO Args) -> TCMT IO Doc -> TCMT IO Args
    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
    =<< QName -> TCMT IO Doc
    forall a (m :: * -> *). (PrettyTCM a, MonadPretty m) => a -> m Doc
    prettyTCM QName
    c TCMT IO Doc -> TCMT IO Doc -> TCMT IO Doc
    forall (m :: * -> *). Applicative m => m Doc -> m Doc -> m Doc
    <+> TCMT IO Doc
    "must be fully applied"