{- -----------------------------------------------------------------------------
Copyright 2020-2021 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE Safe #-}

module Compilation.ScopeContext (
  ProcedureScope(..),
  ScopeContext(..),
  applyProcedureScope,
  builtinVariables,
  getProcedureScopes,
) where

import Control.Monad (when)
import Prelude hiding (pi)
import qualified Data.Map as Map

import Base.CompilerError
import Base.GeneralType
import Base.Positional
import Compilation.ProcedureContext
import Types.DefinedCategory
import Types.Procedure
import Types.TypeCategory
import Types.TypeInstance


data ScopeContext c =
  ScopeContext {
    ScopeContext c -> CategoryMap c
scCategories :: CategoryMap c,
    ScopeContext c -> CategoryName
scName :: CategoryName,
    ScopeContext c -> Positional (ValueParam c)
scExternalParams :: Positional (ValueParam c),
    ScopeContext c -> Positional (ValueParam c)
scInternalparams :: Positional (ValueParam c),
    ScopeContext c -> [DefinedMember c]
scValueMembers :: [DefinedMember c],
    ScopeContext c -> [ParamFilter c]
scExternalFilters :: [ParamFilter c],
    ScopeContext c -> [ParamFilter c]
scInternalFilters :: [ParamFilter c],
    ScopeContext c -> Map FunctionName (ScopedFunction c)
scFunctions :: Map.Map FunctionName (ScopedFunction c),
    ScopeContext c -> Map VariableName (VariableValue c)
scVariables :: Map.Map VariableName (VariableValue c),
    ScopeContext c -> ExprMap c
scExprMap :: ExprMap c
  }

data ProcedureScope c =
  ProcedureScope {
    ProcedureScope c -> ScopeContext c
psContext :: ScopeContext c,
    ProcedureScope c -> [(ScopedFunction c, ExecutableProcedure c)]
psProcedures :: [(ScopedFunction c,ExecutableProcedure c)]
  }

applyProcedureScope ::
  (ScopeContext c -> ScopedFunction c -> ExecutableProcedure c -> a) -> ProcedureScope c -> [a]
applyProcedureScope :: (ScopeContext c -> ScopedFunction c -> ExecutableProcedure c -> a)
-> ProcedureScope c -> [a]
applyProcedureScope ScopeContext c -> ScopedFunction c -> ExecutableProcedure c -> a
f (ProcedureScope ScopeContext c
ctx [(ScopedFunction c, ExecutableProcedure c)]
fs) = ((ScopedFunction c, ExecutableProcedure c) -> a)
-> [(ScopedFunction c, ExecutableProcedure c)] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map ((ScopedFunction c -> ExecutableProcedure c -> a)
-> (ScopedFunction c, ExecutableProcedure c) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (ScopeContext c -> ScopedFunction c -> ExecutableProcedure c -> a
f ScopeContext c
ctx)) [(ScopedFunction c, ExecutableProcedure c)]
fs

getProcedureScopes :: (Show c, CollectErrorsM m) =>
  CategoryMap c -> ExprMap c -> DefinedCategory c -> m [ProcedureScope c]
getProcedureScopes :: CategoryMap c
-> ExprMap c -> DefinedCategory c -> m [ProcedureScope c]
getProcedureScopes CategoryMap c
ta ExprMap c
em (DefinedCategory [c]
c CategoryName
n [ValueParam c]
pi [ValueRefine c]
_ [ValueDefine c]
_ [ParamFilter c]
fi [DefinedMember c]
ms [ExecutableProcedure c]
ps [ScopedFunction c]
fs) = do
  ([c]
_,AnyCategory c
t) <- CategoryMap c -> ([c], CategoryName) -> m ([c], AnyCategory c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> ([c], CategoryName) -> m ([c], AnyCategory c)
getConcreteCategory CategoryMap c
ta ([c]
c,CategoryName
n)
  let params :: Positional (ValueParam c)
params = [ValueParam c] -> Positional (ValueParam c)
forall a. [a] -> Positional a
Positional ([ValueParam c] -> Positional (ValueParam c))
-> [ValueParam c] -> Positional (ValueParam c)
forall a b. (a -> b) -> a -> b
$ AnyCategory c -> [ValueParam c]
forall c. AnyCategory c -> [ValueParam c]
getCategoryParams AnyCategory c
t
  let params2 :: Positional (ValueParam c)
params2 = [ValueParam c] -> Positional (ValueParam c)
forall a. [a] -> Positional a
Positional [ValueParam c]
pi
  let typeInstance :: TypeInstance
typeInstance = CategoryName -> InstanceParams -> TypeInstance
TypeInstance CategoryName
n (InstanceParams -> TypeInstance) -> InstanceParams -> TypeInstance
forall a b. (a -> b) -> a -> b
$ (ValueParam c -> GeneralType TypeInstanceOrParam)
-> Positional (ValueParam c) -> InstanceParams
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TypeInstanceOrParam -> GeneralType TypeInstanceOrParam
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType (TypeInstanceOrParam -> GeneralType TypeInstanceOrParam)
-> (ValueParam c -> TypeInstanceOrParam)
-> ValueParam c
-> GeneralType TypeInstanceOrParam
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> ParamName -> TypeInstanceOrParam
JustParamName Bool
False (ParamName -> TypeInstanceOrParam)
-> (ValueParam c -> ParamName)
-> ValueParam c
-> TypeInstanceOrParam
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueParam c -> ParamName
forall c. ValueParam c -> ParamName
vpParam) Positional (ValueParam c)
params
  let filters :: [ParamFilter c]
filters = AnyCategory c -> [ParamFilter c]
forall c. AnyCategory c -> [ParamFilter c]
getCategoryFilters AnyCategory c
t
  let filters2 :: [ParamFilter c]
filters2 = [ParamFilter c]
fi
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  Map FunctionName (ScopedFunction c)
fa <- CategoryResolver c
-> AnyCategory c
-> [ScopedFunction c]
-> m (Map FunctionName (ScopedFunction c))
forall c (m :: * -> *) r.
(Show c, CollectErrorsM m, TypeResolver r) =>
r
-> AnyCategory c
-> [ScopedFunction c]
-> m (Map FunctionName (ScopedFunction c))
setInternalFunctions CategoryResolver c
r AnyCategory c
t [ScopedFunction c]
fs
  ParamFilters
fm <- AnyCategory c -> m ParamFilters
forall (m :: * -> *) c.
CollectErrorsM m =>
AnyCategory c -> m ParamFilters
getCategoryFilterMap AnyCategory c
t
  [ValueParam c]
-> [ParamFilter c]
-> [ValueParam c]
-> [ScopedFunction c]
-> CategoryResolver c
-> ParamFilters
-> m ()
forall (m :: * -> *) r a a a.
(CollectErrorsM m, TypeResolver r, Show a, Show a, Show a) =>
[ValueParam a]
-> [ParamFilter a]
-> [ValueParam a]
-> [ScopedFunction a]
-> r
-> ParamFilters
-> m ()
checkInternalParams [ValueParam c]
pi [ParamFilter c]
fi (AnyCategory c -> [ValueParam c]
forall c. AnyCategory c -> [ValueParam c]
getCategoryParams AnyCategory c
t) (Map FunctionName (ScopedFunction c) -> [ScopedFunction c]
forall k a. Map k a -> [a]
Map.elems Map FunctionName (ScopedFunction c)
fa) CategoryResolver c
r ParamFilters
fm
  [(ScopedFunction c, ExecutableProcedure c)]
pa <- Map FunctionName (ScopedFunction c)
-> [ExecutableProcedure c]
-> m [(ScopedFunction c, ExecutableProcedure c)]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
Map FunctionName (ScopedFunction c)
-> [ExecutableProcedure c]
-> m [(ScopedFunction c, ExecutableProcedure c)]
pairProceduresToFunctions Map FunctionName (ScopedFunction c)
fa [ExecutableProcedure c]
ps
  let ([(ScopedFunction c, ExecutableProcedure c)]
cp,[(ScopedFunction c, ExecutableProcedure c)]
tp,[(ScopedFunction c, ExecutableProcedure c)]
vp) = ((ScopedFunction c, ExecutableProcedure c) -> SymbolScope)
-> [(ScopedFunction c, ExecutableProcedure c)]
-> ([(ScopedFunction c, ExecutableProcedure c)],
    [(ScopedFunction c, ExecutableProcedure c)],
    [(ScopedFunction c, ExecutableProcedure c)])
forall a. (a -> SymbolScope) -> [a] -> ([a], [a], [a])
partitionByScope (ScopedFunction c -> SymbolScope
forall c. ScopedFunction c -> SymbolScope
sfScope (ScopedFunction c -> SymbolScope)
-> ((ScopedFunction c, ExecutableProcedure c) -> ScopedFunction c)
-> (ScopedFunction c, ExecutableProcedure c)
-> SymbolScope
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ScopedFunction c, ExecutableProcedure c) -> ScopedFunction c
forall a b. (a, b) -> a
fst) [(ScopedFunction c, ExecutableProcedure c)]
pa
  [(ScopedFunction c, ExecutableProcedure c)]
tp' <- ((ScopedFunction c, ExecutableProcedure c)
 -> m (ScopedFunction c, ExecutableProcedure c))
-> [(ScopedFunction c, ExecutableProcedure c)]
-> m [(ScopedFunction c, ExecutableProcedure c)]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM ((ScopedFunction c -> m (ScopedFunction c))
-> (ScopedFunction c, ExecutableProcedure c)
-> m (ScopedFunction c, ExecutableProcedure c)
forall (m :: * -> *) t a b.
Monad m =>
(t -> m a) -> (t, b) -> m (a, b)
firstM ((ScopedFunction c -> m (ScopedFunction c))
 -> (ScopedFunction c, ExecutableProcedure c)
 -> m (ScopedFunction c, ExecutableProcedure c))
-> (ScopedFunction c -> m (ScopedFunction c))
-> (ScopedFunction c, ExecutableProcedure c)
-> m (ScopedFunction c, ExecutableProcedure c)
forall a b. (a -> b) -> a -> b
$ GeneralType TypeInstanceOrParam
-> ScopedFunction c -> m (ScopedFunction c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
GeneralType TypeInstanceOrParam
-> ScopedFunction c -> m (ScopedFunction c)
replaceSelfFunction (AnyCategory c -> GeneralType TypeInstanceOrParam
forall c. AnyCategory c -> GeneralType TypeInstanceOrParam
instanceFromCategory AnyCategory c
t)) [(ScopedFunction c, ExecutableProcedure c)]
tp
  [(ScopedFunction c, ExecutableProcedure c)]
vp' <- ((ScopedFunction c, ExecutableProcedure c)
 -> m (ScopedFunction c, ExecutableProcedure c))
-> [(ScopedFunction c, ExecutableProcedure c)]
-> m [(ScopedFunction c, ExecutableProcedure c)]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM ((ScopedFunction c -> m (ScopedFunction c))
-> (ScopedFunction c, ExecutableProcedure c)
-> m (ScopedFunction c, ExecutableProcedure c)
forall (m :: * -> *) t a b.
Monad m =>
(t -> m a) -> (t, b) -> m (a, b)
firstM ((ScopedFunction c -> m (ScopedFunction c))
 -> (ScopedFunction c, ExecutableProcedure c)
 -> m (ScopedFunction c, ExecutableProcedure c))
-> (ScopedFunction c -> m (ScopedFunction c))
-> (ScopedFunction c, ExecutableProcedure c)
-> m (ScopedFunction c, ExecutableProcedure c)
forall a b. (a -> b) -> a -> b
$ GeneralType TypeInstanceOrParam
-> ScopedFunction c -> m (ScopedFunction c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
GeneralType TypeInstanceOrParam
-> ScopedFunction c -> m (ScopedFunction c)
replaceSelfFunction (AnyCategory c -> GeneralType TypeInstanceOrParam
forall c. AnyCategory c -> GeneralType TypeInstanceOrParam
instanceFromCategory AnyCategory c
t)) [(ScopedFunction c, ExecutableProcedure c)]
vp
  let ([DefinedMember c]
cm,[DefinedMember c]
tm,[DefinedMember c]
vm) = (DefinedMember c -> SymbolScope)
-> [DefinedMember c]
-> ([DefinedMember c], [DefinedMember c], [DefinedMember c])
forall a. (a -> SymbolScope) -> [a] -> ([a], [a], [a])
partitionByScope DefinedMember c -> SymbolScope
forall c. DefinedMember c -> SymbolScope
dmScope [DefinedMember c]
ms
  [DefinedMember c]
tm' <- (DefinedMember c -> m (DefinedMember c))
-> [DefinedMember c] -> m [DefinedMember c]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM (GeneralType TypeInstanceOrParam
-> DefinedMember c -> m (DefinedMember c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
GeneralType TypeInstanceOrParam
-> DefinedMember c -> m (DefinedMember c)
replaceSelfMember (AnyCategory c -> GeneralType TypeInstanceOrParam
forall c. AnyCategory c -> GeneralType TypeInstanceOrParam
instanceFromCategory AnyCategory c
t)) [DefinedMember c]
tm
  [DefinedMember c]
vm' <- (DefinedMember c -> m (DefinedMember c))
-> [DefinedMember c] -> m [DefinedMember c]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM (GeneralType TypeInstanceOrParam
-> DefinedMember c -> m (DefinedMember c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
GeneralType TypeInstanceOrParam
-> DefinedMember c -> m (DefinedMember c)
replaceSelfMember (AnyCategory c -> GeneralType TypeInstanceOrParam
forall c. AnyCategory c -> GeneralType TypeInstanceOrParam
instanceFromCategory AnyCategory c
t)) [DefinedMember c]
vm
  let cm0 :: Map VariableName (VariableValue c)
cm0 = TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
forall c.
TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
builtins TypeInstance
typeInstance SymbolScope
CategoryScope
  let tm0 :: Map VariableName (VariableValue c)
tm0 = TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
forall c.
TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
builtins TypeInstance
typeInstance SymbolScope
TypeScope
  let vm0 :: Map VariableName (VariableValue c)
vm0 = TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
forall c.
TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
builtins TypeInstance
typeInstance SymbolScope
ValueScope
  Map VariableName (VariableValue c)
cm2 <- [DefinedMember c] -> m (Map VariableName (VariableValue c))
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
[DefinedMember c] -> m (Map VariableName (VariableValue c))
mapMembers [DefinedMember c]
cm
  Map VariableName (VariableValue c)
tm2 <- [DefinedMember c] -> m (Map VariableName (VariableValue c))
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
[DefinedMember c] -> m (Map VariableName (VariableValue c))
mapMembers ([DefinedMember c] -> m (Map VariableName (VariableValue c)))
-> [DefinedMember c] -> m (Map VariableName (VariableValue c))
forall a b. (a -> b) -> a -> b
$ [DefinedMember c]
cm [DefinedMember c] -> [DefinedMember c] -> [DefinedMember c]
forall a. [a] -> [a] -> [a]
++ [DefinedMember c]
tm'
  Map VariableName (VariableValue c)
vm2 <- [DefinedMember c] -> m (Map VariableName (VariableValue c))
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
[DefinedMember c] -> m (Map VariableName (VariableValue c))
mapMembers ([DefinedMember c] -> m (Map VariableName (VariableValue c)))
-> [DefinedMember c] -> m (Map VariableName (VariableValue c))
forall a b. (a -> b) -> a -> b
$ [DefinedMember c]
cm [DefinedMember c] -> [DefinedMember c] -> [DefinedMember c]
forall a. [a] -> [a] -> [a]
++ [DefinedMember c]
tm' [DefinedMember c] -> [DefinedMember c] -> [DefinedMember c]
forall a. [a] -> [a] -> [a]
++ [DefinedMember c]
vm'
  let cv :: Map VariableName (VariableValue c)
cv = Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map VariableName (VariableValue c)
forall c. Map VariableName (VariableValue c)
cm0 Map VariableName (VariableValue c)
cm2
  let tv :: Map VariableName (VariableValue c)
tv = Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map VariableName (VariableValue c)
forall c. Map VariableName (VariableValue c)
tm0 Map VariableName (VariableValue c)
tm2
  let vv :: Map VariableName (VariableValue c)
vv = Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union Map VariableName (VariableValue c)
forall c. Map VariableName (VariableValue c)
vm0 Map VariableName (VariableValue c)
vm2
  let ctxC :: ScopeContext c
ctxC = CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
forall c.
CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
ScopeContext CategoryMap c
ta CategoryName
n Positional (ValueParam c)
params Positional (ValueParam c)
params2 [DefinedMember c]
vm' [ParamFilter c]
filters [ParamFilter c]
filters2 Map FunctionName (ScopedFunction c)
fa Map VariableName (VariableValue c)
cv ExprMap c
em
  let ctxT :: ScopeContext c
ctxT = CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
forall c.
CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
ScopeContext CategoryMap c
ta CategoryName
n Positional (ValueParam c)
params Positional (ValueParam c)
params2 [DefinedMember c]
vm' [ParamFilter c]
filters [ParamFilter c]
filters2 Map FunctionName (ScopedFunction c)
fa Map VariableName (VariableValue c)
tv ExprMap c
em
  let ctxV :: ScopeContext c
ctxV = CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
forall c.
CategoryMap c
-> CategoryName
-> Positional (ValueParam c)
-> Positional (ValueParam c)
-> [DefinedMember c]
-> [ParamFilter c]
-> [ParamFilter c]
-> Map FunctionName (ScopedFunction c)
-> Map VariableName (VariableValue c)
-> ExprMap c
-> ScopeContext c
ScopeContext CategoryMap c
ta CategoryName
n Positional (ValueParam c)
params Positional (ValueParam c)
params2 [DefinedMember c]
vm' [ParamFilter c]
filters [ParamFilter c]
filters2 Map FunctionName (ScopedFunction c)
fa Map VariableName (VariableValue c)
vv ExprMap c
em
  [ProcedureScope c] -> m [ProcedureScope c]
forall (m :: * -> *) a. Monad m => a -> m a
return [ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
forall c.
ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
ProcedureScope ScopeContext c
ctxC [(ScopedFunction c, ExecutableProcedure c)]
cp,ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
forall c.
ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
ProcedureScope ScopeContext c
ctxT [(ScopedFunction c, ExecutableProcedure c)]
tp',ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
forall c.
ScopeContext c
-> [(ScopedFunction c, ExecutableProcedure c)] -> ProcedureScope c
ProcedureScope ScopeContext c
ctxV [(ScopedFunction c, ExecutableProcedure c)]
vp']
  where
    firstM :: (t -> m a) -> (t, b) -> m (a, b)
firstM t -> m a
f (t
x,b
y) = do
      a
x' <- t -> m a
f t
x
      (a, b) -> m (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x',b
y)
    builtins :: TypeInstance -> SymbolScope -> Map VariableName (VariableValue c)
builtins TypeInstance
t SymbolScope
s0 = (VariableValue c -> Bool)
-> Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter ((SymbolScope -> SymbolScope -> Bool
forall a. Ord a => a -> a -> Bool
<= SymbolScope
s0) (SymbolScope -> Bool)
-> (VariableValue c -> SymbolScope) -> VariableValue c -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VariableValue c -> SymbolScope
forall c. VariableValue c -> SymbolScope
vvScope) (Map VariableName (VariableValue c)
 -> Map VariableName (VariableValue c))
-> Map VariableName (VariableValue c)
-> Map VariableName (VariableValue c)
forall a b. (a -> b) -> a -> b
$ TypeInstance -> Map VariableName (VariableValue c)
forall c. TypeInstance -> Map VariableName (VariableValue c)
builtinVariables TypeInstance
t
    checkInternalParams :: [ValueParam a]
-> [ParamFilter a]
-> [ValueParam a]
-> [ScopedFunction a]
-> r
-> ParamFilters
-> m ()
checkInternalParams [ValueParam a]
pi2 [ParamFilter a]
fi2 [ValueParam a]
pe [ScopedFunction a]
fs2 r
r ParamFilters
fa = do
      let pm :: Map ParamName [a]
pm = [(ParamName, [a])] -> Map ParamName [a]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(ParamName, [a])] -> Map ParamName [a])
-> [(ParamName, [a])] -> Map ParamName [a]
forall a b. (a -> b) -> a -> b
$ (ValueParam a -> (ParamName, [a]))
-> [ValueParam a] -> [(ParamName, [a])]
forall a b. (a -> b) -> [a] -> [b]
map (\ValueParam a
p -> (ValueParam a -> ParamName
forall c. ValueParam c -> ParamName
vpParam ValueParam a
p,ValueParam a -> [a]
forall c. ValueParam c -> [c]
vpContext ValueParam a
p)) [ValueParam a]
pi2
      (ScopedFunction a -> m ()) -> [ScopedFunction a] -> m ()
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m ()
mapCompilerM_ (Map ParamName [a] -> ScopedFunction a -> m ()
forall (f :: * -> *) a a.
(CollectErrorsM f, Show a, Show a) =>
Map ParamName [a] -> ScopedFunction a -> f ()
checkFunction Map ParamName [a]
pm) [ScopedFunction a]
fs2
      (ValueParam a -> m ()) -> [ValueParam a] -> m ()
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m ()
mapCompilerM_ (Map ParamName [a] -> ValueParam a -> m ()
forall (m :: * -> *) a a.
(ErrorContextM m, Show a, Show a) =>
Map ParamName [a] -> ValueParam a -> m ()
checkParam Map ParamName [a]
pm) [ValueParam a]
pe
      ParamFilters
fa' <- (ParamFilters -> ParamFilters) -> m ParamFilters -> m ParamFilters
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ParamFilters -> ParamFilters -> ParamFilters
forall k a. Ord k => Map k a -> Map k a -> Map k a
Map.union ParamFilters
fa) (m ParamFilters -> m ParamFilters)
-> m ParamFilters -> m ParamFilters
forall a b. (a -> b) -> a -> b
$ [ValueParam a] -> [ParamFilter a] -> m ParamFilters
forall (m :: * -> *) c.
CollectErrorsM m =>
[ValueParam c] -> [ParamFilter c] -> m ParamFilters
getFilterMap [ValueParam a]
pi2 [ParamFilter a]
fi2
      (ParamFilter a -> m ()) -> [ParamFilter a] -> m ()
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m ()
mapCompilerM_ (r -> ParamFilters -> ParamFilter a -> m ()
forall (m :: * -> *) r a.
(CollectErrorsM m, TypeResolver r, Show a) =>
r -> ParamFilters -> ParamFilter a -> m ()
checkFilter r
r ParamFilters
fa') [ParamFilter a]
fi2
    checkFilter :: r -> ParamFilters -> ParamFilter a -> m ()
checkFilter r
r ParamFilters
fa (ParamFilter [a]
c2 ParamName
n2 TypeFilter
f) =
      r -> ParamFilters -> TypeFilter -> m ()
forall (m :: * -> *) r.
(CollectErrorsM m, TypeResolver r) =>
r -> ParamFilters -> TypeFilter -> m ()
validateTypeFilter r
r ParamFilters
fa TypeFilter
f m () -> String -> m ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
<?? String
"In " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ParamName -> String
forall a. Show a => a -> String
show ParamName
n2 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ TypeFilter -> String
forall a. Show a => a -> String
show TypeFilter
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ [a] -> String
forall a. Show a => [a] -> String
formatFullContextBrace [a]
c2
    checkFunction :: Map ParamName [a] -> ScopedFunction a -> f ()
checkFunction Map ParamName [a]
pm ScopedFunction a
f =
      Bool -> f () -> f ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (ScopedFunction a -> SymbolScope
forall c. ScopedFunction c -> SymbolScope
sfScope ScopedFunction a
f SymbolScope -> SymbolScope -> Bool
forall a. Eq a => a -> a -> Bool
== SymbolScope
ValueScope) (f () -> f ()) -> f () -> f ()
forall a b. (a -> b) -> a -> b
$
        (ValueParam a -> f ()) -> [ValueParam a] -> f ()
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m ()
mapCompilerM_ (Map ParamName [a] -> ValueParam a -> f ()
forall (m :: * -> *) a a.
(ErrorContextM m, Show a, Show a) =>
Map ParamName [a] -> ValueParam a -> m ()
checkParam Map ParamName [a]
pm) ([ValueParam a] -> f ()) -> [ValueParam a] -> f ()
forall a b. (a -> b) -> a -> b
$ Positional (ValueParam a) -> [ValueParam a]
forall a. Positional a -> [a]
pValues (Positional (ValueParam a) -> [ValueParam a])
-> Positional (ValueParam a) -> [ValueParam a]
forall a b. (a -> b) -> a -> b
$ ScopedFunction a -> Positional (ValueParam a)
forall c. ScopedFunction c -> Positional (ValueParam c)
sfParams ScopedFunction a
f
    checkParam :: Map ParamName [a] -> ValueParam a -> m ()
checkParam Map ParamName [a]
pm ValueParam a
p =
      case ValueParam a -> ParamName
forall c. ValueParam c -> ParamName
vpParam ValueParam a
p ParamName -> Map ParamName [a] -> Maybe [a]
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` Map ParamName [a]
pm of
           Maybe [a]
Nothing -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
           (Just [a]
c2) -> String -> m ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Internal param " String -> String -> String
forall a. [a] -> [a] -> [a]
++ ParamName -> String
forall a. Show a => a -> String
show (ValueParam a -> ParamName
forall c. ValueParam c -> ParamName
vpParam ValueParam a
p) String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                        [a] -> String
forall a. Show a => [a] -> String
formatFullContextBrace (ValueParam a -> [a]
forall c. ValueParam c -> [c]
vpContext ValueParam a
p) String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                        String
" is already defined at " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                        [a] -> String
forall a. Show a => [a] -> String
formatFullContext [a]
c2

-- TODO: This is probably in the wrong module.
builtinVariables :: TypeInstance -> Map.Map VariableName (VariableValue c)
builtinVariables :: TypeInstance -> Map VariableName (VariableValue c)
builtinVariables TypeInstance
t = [(VariableName, VariableValue c)]
-> Map VariableName (VariableValue c)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [
    (String -> VariableName
VariableName String
"self",[c]
-> SymbolScope -> ValueType -> VariableRule c -> VariableValue c
forall c.
[c]
-> SymbolScope -> ValueType -> VariableRule c -> VariableValue c
VariableValue [] SymbolScope
ValueScope (StorageType -> GeneralType TypeInstanceOrParam -> ValueType
ValueType StorageType
RequiredValue (GeneralType TypeInstanceOrParam -> ValueType)
-> GeneralType TypeInstanceOrParam -> ValueType
forall a b. (a -> b) -> a -> b
$ TypeInstanceOrParam -> GeneralType TypeInstanceOrParam
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType (TypeInstanceOrParam -> GeneralType TypeInstanceOrParam)
-> TypeInstanceOrParam -> GeneralType TypeInstanceOrParam
forall a b. (a -> b) -> a -> b
$ TypeInstance -> TypeInstanceOrParam
JustTypeInstance TypeInstance
t) ([c] -> VariableRule c
forall c. [c] -> VariableRule c
VariableReadOnly []))
  ]