-- |
-- Module      :  $Header$
-- Copyright   :  (c) 2013-2014 Galois, Inc.
-- License     :  BSD3
-- Maintainer  :  cryptol@galois.com
-- Stability   :  provisional
-- Portability :  portable

{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 706
{-# LANGUAGE RecursiveDo #-}
#else
{-# LANGUAGE DoRec, RecursiveDo #-}
#endif
{-# LANGUAGE Safe #-}
module Cryptol.TypeCheck.Kind
  ( checkType
  , checkSchema
  , checkNewtype
  , checkTySyn
  ) where

import qualified Cryptol.Parser.AST as P
import           Cryptol.Parser.AST (Named(..))
import           Cryptol.Parser.Position
import           Cryptol.TypeCheck.AST
import           Cryptol.TypeCheck.Monad hiding (withTParams)
import           Cryptol.TypeCheck.Solve (simplifyAllConstraints
                                         ,checkTypeFunction)
import           Cryptol.Utils.PP

import qualified Data.Map as Map
import           Data.List(sortBy,groupBy)
import           Data.Maybe(fromMaybe)
import           Data.Function(on)
import           Control.Monad(unless,forM)



-- | Check a type signature.
checkSchema :: P.Schema -> InferM (Schema, [Goal])
checkSchema (P.Forall xs ps t mb) =
  do ((xs1,(ps1,t1)), gs) <-
        collectGoals $
        rng $ withTParams True xs $
        do ps1 <- mapM checkProp ps
           t1  <- doCheckType t (Just KType)
           return (ps1,t1)
     return (Forall xs1 ps1 t1, gs)

  where
  rng = case mb of
          Nothing -> id
          Just r  -> inRange r

-- | Check a type-synonym declaration.
checkTySyn :: P.TySyn -> InferM TySyn
checkTySyn (P.TySyn x as t) =
  do ((as1,t1),gs) <- collectGoals
                    $ inRange (srcRange x)
                    $ do r <- withTParams False as (doCheckType t Nothing)
                         simplifyAllConstraints
                         return r
     return TySyn { tsName   = thing x
                  , tsParams = as1
                  , tsConstraints = map goal gs
                  , tsDef = t1
                  }

-- | Check a newtype declaration.
-- XXX: Do something with constraints.
checkNewtype :: P.Newtype -> InferM Newtype
checkNewtype (P.Newtype x as fs) =
  do ((as1,fs1),gs) <- collectGoals $
       inRange (srcRange x) $
       do r <- withTParams False as $
               forM fs $ \field ->
                 let n = name field
                 in kInRange (srcRange n) $
                    do t1 <- doCheckType (value field) (Just KType)
                       return (thing n, t1)
          simplifyAllConstraints
          return r

     return Newtype { ntName   = thing x
                    , ntParams = as1
                    , ntConstraints = map goal gs
                    , ntFields = fs1
                    }



checkType :: P.Type -> Maybe Kind -> InferM Type
checkType t k =
  do (_, t1) <- withTParams True [] $ doCheckType t k
     return t1

{- | Check someting with type parameters.

When we check things with type parameters (i.e., type schemas, and type
synonym declarations) we do kind inference based only on the immediately
visible body.  Type parameters that are not mentioned in the body are
defaulted to kind 'KNum'.  If this is not the desired behavior, programmers
may add explicit kind annotations on the type parameters.

Here is an example of how this may show up:

> f : {n}. [8] -> [8]
> f x =  x + `n

Note that @n@ does not appear in the body of the schema, so we will
default it to 'KNum', which is the correct thing in this case.
To use such a function, we'd have to provide an explicit type application:

> f `{n = 3}

There are two reasons for this choice:

  1. It makes it possible to figure if something is correct without
     having to look trough arbitrary amounts of code.

  2. It is a bit easier to implement, and it covers the large majority
     of use cases, with a very small inconvenience (an explicit kind
     annotation) in the rest.
-}

withTParams :: Bool -> [P.TParam] -> KindM a -> InferM ([TParam], a)
withTParams allowWildCards xs m =
  mdo mapM_ recordError duplicates
      (a, vars) <- runKindM allowWildCards (zip' xs ts) m
      (as, ts)  <- unzip `fmap` mapM (newTP vars) xs
      return (as,a)
  where
  getKind vs tp =
    case Map.lookup (P.tpQName tp) vs of
      Just k  -> return k
      Nothing -> do recordWarning (DefaultingKind tp P.KNum)
                    return KNum

  newTP vs tp = do k <- getKind vs tp
                   n <- newTParam (Just (mkUnqual (P.tpName tp))) k
                   return (n, TVar (tpVar n))


  {- Note that we only zip based on the first argument.
  This is needed to make the monadic recursion work correctly,
  because the data dependency is only on the part that is known. -}
  zip' [] _           = []
  zip' (a:as) ~(t:ts) = (mkUnqual (P.tpName a), fmap cvtK (P.tpKind a), t) : zip' as ts

  cvtK P.KNum  = KNum
  cvtK P.KType = KType

  duplicates = [ RepeatedTyParams ds
                    | ds@(_ : _ : _) <- groupBy ((==) `on` P.tpName)
                                      $ sortBy (compare `on` P.tpName) xs ]

-- | Check an application of a type constant.
tcon :: TCon            -- ^ Type constant being applied
     -> [P.Type]        -- ^ Type parameters
     -> Maybe Kind      -- ^ Expected kind
     -> KindM Type      -- ^ Resulting type
tcon tc ts0 k =
  do (ts1,k1) <- appTy ts0 (kindOf tc)
     checkKind (TCon tc ts1) k k1

-- | Check a use of a type-synonym, newtype, or scoped-type variable.
tySyn :: Bool         -- ^ Should we check for scoped type vars.
      -> QName        -- ^ Name of type sysnonym
      -> [P.Type]     -- ^ Type synonym parameters
      -> Maybe Kind   -- ^ Expected kind
      -> KindM Type   -- ^ Resulting type
tySyn scoped x ts k =
  do mb <- kLookupTSyn x
     case mb of
       Just (tysyn@(TySyn f as ps def)) ->
          do (ts1,k1) <- appTy ts (kindOf tysyn)
             ts2 <- checkParams as ts1
             let su = zip as ts2
             ps1 <- mapM (`kInstantiateT` su) ps
             kNewGoals (CtPartialTypeFun (UserTyFun f)) ps1
             t1  <- kInstantiateT def su
             checkKind (TUser x ts1 t1) k k1

       -- Maybe it is a newtype?
       Nothing ->
         do mbN <- kLookupNewtype x
            case mbN of
              Just nt ->
                do let tc = newtypeTyCon nt
                   (ts1,_) <- appTy ts (kindOf tc)
                   ts2 <- checkParams (ntParams nt) ts1
                   return (TCon tc ts2)

              -- Maybe it is a scoped type variable?
              Nothing
                | scoped -> kExistTVar x $ fromMaybe KNum k
                | otherwise ->
                  do kRecordError $ UndefinedTypeSynonym x
                     kNewType (text "type synonym" <+> pp x) $ fromMaybe KNum k
  where
  checkParams as ts1
    | paramHave == paramNeed = return ts1
    | paramHave < paramNeed  =
                   do kRecordError (TooFewTySynParams x (paramNeed-paramHave))
                      let src = text "missing prameter of" <+> pp x
                      fake <- mapM (kNewType src . kindOf . tpVar)
                                   (drop paramHave as)
                      return (ts1 ++ fake)
    | otherwise = do kRecordError (TooManyTySynParams x (paramHave-paramNeed))
                     return (take paramNeed ts1)
    where paramHave = length ts1
          paramNeed = length as


-- | Check a type-application.
appTy :: [P.Type]             -- ^ Parameters to type function
      -> Kind                 -- ^ Kind of type function
      -> KindM ([Type], Kind) -- ^ Validated parameters, resulting kind
appTy [] k1 = return ([],k1)

appTy (t : ts) (k1 :-> k2) =
  do t1      <- doCheckType t (Just k1)
     (ts1,k) <- appTy ts k2
     return (t1 : ts1, k)

appTy ts k1 =
  do kRecordError (TooManyTypeParams (length ts) k1)
     return ([], k1)


-- | Validate a parsed type.
doCheckType :: P.Type         -- ^ Type that needs to be checked
          -> Maybe Kind     -- ^ Expected kind (if any)
          -> KindM Type     -- ^ Checked type
doCheckType ty k =
  case ty of
    P.TWild         ->
      do ok <- kWildOK
         unless ok $ kRecordError UnexpectedTypeWildCard
         theKind <- case k of
                      Just k1 -> return k1
                      Nothing -> do kRecordWarning (DefaultingWildType P.KNum)
                                    return KNum
         kNewType (text "wildcard") theKind

    P.TFun t1 t2    -> tcon (TC TCFun)                 [t1,t2] k
    P.TSeq t1 t2    -> tcon (TC TCSeq)                 [t1,t2] k
    P.TBit          -> tcon (TC TCBit)                 [] k
    P.TNum n        -> tcon (TC (TCNum n))             [] k
    P.TChar n       -> tcon (TC (TCNum $ fromIntegral $ fromEnum n)) [] k
    P.TInf          -> tcon (TC TCInf)                 [] k
    P.TApp tf ts    ->
      do it <- tcon (TF tf) ts k

         -- Now check for additional well-formedness
         -- constraints.
         case it of
           TCon (TF f) ts' ->
              case checkTypeFunction f ts' of
                 [] -> return ()
                 ps -> kNewGoals (CtPartialTypeFun (BuiltInTyFun f)) ps
           _ -> return ()

         return it
    P.TTuple ts     -> tcon (TC (TCTuple (length ts))) ts k

    P.TRecord fs    -> do t1 <- TRec `fmap` mapM checkF fs
                          checkKind t1 k KType
    P.TLocated t r1 -> kInRange r1 $ doCheckType t k

    P.TUser x []    -> checkTyThing x k
    P.TUser x ts    -> tySyn False x ts k

  where
  checkF f = do t <- kInRange (srcRange (name f))
                   $ doCheckType (value f) (Just KType)
                return (thing (name f), t)



-- | Check a type-variable or type-synonym.
checkTyThing :: QName         -- ^ Name of thing that needs checking
             -> Maybe Kind    -- ^ Expected kind
             -> KindM Type
checkTyThing x k =
  do it <- kLookupTyVar x
     case it of
       Just (TLocalVar t mbk) ->
         case k of
           Nothing -> return t
           Just k1 ->
             case mbk of
               Nothing -> kSetKind x k1 >> return t
               Just k2 -> checkKind t k k2

       Just (TOuterVar t) -> checkKind t k (kindOf t)
       Nothing            -> tySyn True x [] k


-- | Validate a parsed proposition.
checkProp :: P.Prop           -- ^ Proposition that need to be checked
          -> KindM Type       -- ^ Checked representation
checkProp prop =
  case prop of
    P.CFin t1       -> tcon (PC PFin)           [t1]    (Just KProp)
    P.CEqual t1 t2  -> tcon (PC PEqual)         [t1,t2] (Just KProp)
    P.CGeq t1 t2    -> tcon (PC PGeq)           [t1,t2] (Just KProp)
    P.CArith t1     -> tcon (PC PArith)         [t1]    (Just KProp)
    P.CCmp t1       -> tcon (PC PCmp)           [t1]    (Just KProp)
    P.CLocated p r1 -> kInRange r1 (checkProp p)


-- | Check that a type has the expected kind.
checkKind :: Type         -- ^ Kind-checked type
          -> Maybe Kind   -- ^ Expected kind (if any)
          -> Kind         -- ^ Inferred kind
          -> KindM Type   -- ^ A type consistent with expectations.
checkKind _ (Just k1) k2
  | k1 /= k2    = do kRecordError (KindMismatch k1 k2)
                     kNewType (text "kind error") k1
checkKind t _ _ = return t


