{- -----------------------------------------------------------------------------
Copyright 2019-2021,2023 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]


module Test.TypeCategory (tests) where

import Control.Arrow
import Control.Monad ((>=>),when)
import System.FilePath
import Text.Regex.TDFA
import qualified Data.Map as Map
import qualified Data.Set as Set

import Base.CompilerError
import Base.GeneralType
import Base.Positional
import Base.TrackedErrors
import Parser.TextParser (SourceContext)
import Parser.TypeCategory ()
import Test.Common
import Types.TypeCategory
import Types.TypeInstance
import Types.Variance


tests :: [IO (TrackedErrors ())]
tests :: [IO (TrackedErrors ())]
tests = [
    String -> IO (TrackedErrors ())
checkSingleParseSuccess (String
"testfiles" String -> String -> String
</> String
"value_interface.0rx"),
    String -> IO (TrackedErrors ())
checkSingleParseSuccess (String
"testfiles" String -> String -> String
</> String
"type_interface.0rx"),
    String -> IO (TrackedErrors ())
checkSingleParseSuccess (String
"testfiles" String -> String -> String
</> String
"concrete.0rx"),

    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x> {}",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<T> {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<optional> {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<optional T> {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<T<#x>> {}",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type { refines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type { refines #x }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type { defines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type { defines #x }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type { refines optional }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type { refines optional T }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x|#y> { #x requires #y }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x|#y> { #x allows #y }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x|#y> { #x defines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<#x|#y> { #x defines #y }",

    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@type interface Type<#x> {}",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@type interface Type {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@type interface Type { refines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@type interface Type { defines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@type interface Type<#x> { #x allows T }",

    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@value interface Type<#x> {}",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@value interface Type {}",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@value interface Type { refines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { defines T }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type<#x> { #x allows T }",

    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"@value interface Type { call () -> (#self) }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type<#self> {}",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { refines #self }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { #self allows Foo }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { #self requires Foo }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { #self defines Foo }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x> { #x allows #self }",
    String -> IO (TrackedErrors ())
checkShortParseSuccess String
"concrete Type<#x> { #x requires #self }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"concrete Type<#x> { #x defines #self }",
    String -> IO (TrackedErrors ())
checkShortParseFail String
"@value interface Type { call<#self> () -> () }",

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"value_refines_value.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"value_refines_instance.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"value_refines_concrete.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"concrete_refines_instance.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"concrete_refines_concrete.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"concrete_defines_instance.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"concrete_defines_value.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"concrete_defines_concrete.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent2",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent2") [] [] [])
        ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [])
        ]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [] [])
        ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [])
        ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [FunctionVisibility SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ValueDefine SourceContext]
-> [ParamFilter SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [FunctionVisibility c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ValueDefine c]
-> [ParamFilter c]
-> [ScopedFunction c]
-> AnyCategory c
ValueConcrete [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [] [] [] [] [])
        ]),
    String
-> String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFailWith String
"Parent.+not found"
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFailWith String
"Parent.+not visible"
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectedTypes (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ Map CategoryName [SourceContext]
-> Map CategoryName (AnyCategory SourceContext)
-> CategoryMap SourceContext
forall c.
Map CategoryName [c]
-> Map CategoryName (AnyCategory c) -> CategoryMap c
CategoryMap ([(CategoryName, [SourceContext])]
-> Map CategoryName [SourceContext]
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(String -> CategoryName
CategoryName String
"Parent",[])]) Map CategoryName (AnyCategory SourceContext)
forall k a. Map k a
Map.empty),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"value_refines_value.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectionCycles CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectionCycles CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"concrete_defines_instance.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectionCycles CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"value_cycle.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkConnectionCycles CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        (AnyCategory SourceContext -> String)
-> [AnyCategory SourceContext] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (CategoryName -> String
forall a. Show a => a -> String
show (CategoryName -> String)
-> (AnyCategory SourceContext -> CategoryName)
-> AnyCategory SourceContext
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnyCategory SourceContext -> CategoryName
forall c. AnyCategory c -> CategoryName
getCategoryName) [AnyCategory SourceContext]
ts2 [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [
            String
"Object2",String
"Object3",String
"Object1",String
"Type",String
"Parent",String
"Child"
          ]),
    String
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity [AnyCategory SourceContext])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [AnyCategory SourceContext] -> [(String, String)]
forall c. [AnyCategory c] -> [(String, String)]
scrapeAllRefines [AnyCategory SourceContext]
ts3 [(String, String)] -> [(String, String)] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` [
            (String
"Object1",String
"Object3<#y>"),
            (String
"Object1",String
"Object2"),
            (String
"Object3",String
"Object2"),
            (String
"Parent",String
"Object1<#x,Object3<Object2>>"),
            (String
"Parent",String
"Object3<Object3<Object2>>"),
            (String
"Parent",String
"Object2"),
            (String
"Child",String
"Parent<Child>"),
            (String
"Child",String
"Object1<Child,Object3<Object2>>"),
            (String
"Child",String
"Object3<Object3<Object2>>"),
            (String
"Child",String
"Object2")
          ]
        [AnyCategory SourceContext] -> [(String, String)]
forall c. [AnyCategory c] -> [(String, String)]
scrapeAllDefines [AnyCategory SourceContext]
ts3 [(String, String)] -> [(String, String)] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` [
            (String
"Child",String
"Type<Child>")
          ]),

    String
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity [AnyCategory SourceContext])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
existing  <- CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (CategoryMap SourceContext
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
            (String -> CategoryName
CategoryName String
"Parent2",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent2") [] [] [])
          ]
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
existing [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
existing [AnyCategory SourceContext]
ts2),
    String
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity [AnyCategory SourceContext])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
existing  <- CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (CategoryMap SourceContext
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
            (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [])
          ]
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
existing [AnyCategory SourceContext]
ts),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"partial.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
existing  <- CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (CategoryMap SourceContext
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> CategoryMap SourceContext
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
            (String -> CategoryName
CategoryName String
"Parent",
            [SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] []
                           [[SourceContext] -> TypeInstance -> ValueRefine SourceContext
forall c. [c] -> TypeInstance -> ValueRefine c
ValueRefine [] (TypeInstance -> ValueRefine SourceContext)
-> TypeInstance -> ValueRefine SourceContext
forall a b. (a -> b) -> a -> b
$ CategoryName -> InstanceParams -> TypeInstance
TypeInstance (String -> CategoryName
CategoryName String
"Object1") ([GeneralInstance] -> InstanceParams
forall a. [a] -> Positional a
Positional []),
                            [SourceContext] -> TypeInstance -> ValueRefine SourceContext
forall c. [c] -> TypeInstance -> ValueRefine c
ValueRefine [] (TypeInstance -> ValueRefine SourceContext)
-> TypeInstance -> ValueRefine SourceContext
forall a b. (a -> b) -> a -> b
$ CategoryName -> InstanceParams -> TypeInstance
TypeInstance (String -> CategoryName
CategoryName String
"Object2") ([GeneralInstance] -> InstanceParams
forall a. [a] -> Positional a
Positional [])] []),
            -- NOTE: Object1 deliberately excluded here so that we catch
            -- unnecessary recursion in existing categories.
            (String -> CategoryName
CategoryName String
"Object2",
            [SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Object2") [] [] [] [])
          ]
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
existing [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
existing [AnyCategory SourceContext]
ts2
        [AnyCategory SourceContext] -> [(String, String)]
forall c. [AnyCategory c] -> [(String, String)]
scrapeAllRefines [AnyCategory SourceContext]
ts3 [(String, String)] -> [(String, String)] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` [
            (String
"Child",String
"Parent"),
            (String
"Child",String
"Object1"),
            (String
"Child",String
"Object2")
          ]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess (String
"testfiles" String -> String -> String
</> String
"valid_variances.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"contravariant_refines_covariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"contravariant_refines_invariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"covariant_refines_contravariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"covariant_refines_invariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"contravariant_defines_covariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"contravariant_defines_invariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"covariant_defines_contravariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"covariant_defines_invariant.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"concrete_duplicate_param.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"type_duplicate_param.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail (String
"testfiles" String -> String -> String
</> String
"value_duplicate_param.0rx") (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent2",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent2") [] [] [])
        ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"concrete_refines_value.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",[SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") [] [] [])
        ]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"partial_params.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",
           [SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") []
                          [[SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#w") Variance
Contravariant,
                           [SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#z") Variance
Covariant] [] [])
      ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"partial_params.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",
           [SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") []
                          [[SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#w") Variance
Invariant,
                           [SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#z") Variance
Covariant] [] [])
      ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"partial_params.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances (CategoryMap SourceContext
 -> [AnyCategory SourceContext] -> TrackedErrors ())
-> CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ [(CategoryName, AnyCategory SourceContext)]
-> CategoryMap SourceContext
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
          (String -> CategoryName
CategoryName String
"Parent",
           [SourceContext]
-> Namespace
-> CategoryName
-> [PragmaCategory SourceContext]
-> [ValueParam SourceContext]
-> [ValueRefine SourceContext]
-> [ScopedFunction SourceContext]
-> AnyCategory SourceContext
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ValueRefine c]
-> [ScopedFunction c]
-> AnyCategory c
ValueInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent") []
                          [[SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#w") Variance
Contravariant,
                           [SourceContext]
-> ParamName -> Variance -> ValueParam SourceContext
forall c. [c] -> ParamName -> Variance -> ValueParam c
ValueParam [] (String -> ParamName
ParamName String
"#z") Variance
Invariant] [] [])
      ]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts String
"Type<#a,#b,#c,#d,#e,#f>" String
"Type"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#a",String
"#b",String
"#c",String
"#d",String
"#e",String
"#f"]
        ),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Object1<#a,#b>" String
"Object1"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#a",String
"#b"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Object1<#a,#b>" String
"Object3"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#b"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Undefined<#a,#b>" String
"Undefined"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#a",String
"#b"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Object1<#a>" String
"Object1"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#a"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Parent<#t>" String
"Object1"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"#t",String
"Object3<Object2>"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [String])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Parent<#t>" String
"Child"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [String])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Child" String
"Type"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [String])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory SourceContext]
ts3 String
"Child" String
"Missing"),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [String]
rs <- [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeDefines [AnyCategory SourceContext]
ts String
"Child" String
"Type"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [String
"Child"]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [String])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeDefines [AnyCategory SourceContext]
ts String
"Child" String
"Parent"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [String])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
-> String -> String -> TrackedErrors [String]
forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeDefines [AnyCategory SourceContext]
ts String
"Child" String
"Missing"),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [Variance]
vs <- [AnyCategory SourceContext] -> String -> TrackedErrors [Variance]
forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [Variance]
getTypeVariance [AnyCategory SourceContext]
ts String
"Type"
        [Variance]
vs [Variance] -> [Variance] -> TrackedErrors ()
forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsPaired` [Variance
Contravariant,Variance
Contravariant,
                             Variance
Invariant,Variance
Invariant,
                             Variance
Covariant,Variance
Covariant]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors [Variance])
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext] -> String -> TrackedErrors [Variance]
forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [Variance]
getTypeVariance [AnyCategory SourceContext]
ts String
"Missing"),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [[String]]
rs <- [AnyCategory SourceContext] -> String -> TrackedErrors [[String]]
forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeFilters [AnyCategory SourceContext]
ts String
"Type<#a,#b,#c,#d,#e,#f>"
        ([String] -> [String] -> TrackedErrors ())
-> [[String]] -> [[String]] -> TrackedErrors ()
forall a.
Show a =>
(a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
checkPaired [String] -> [String] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
containsExactly [[String]]
rs [
            [String
"allows Parent"],
            [String
"requires Type2<#a>"],
            [String
"defines Equals<#c>"],
            [],
            [],
            []
          ]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"concrete.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [[String]]
rs <- [AnyCategory SourceContext] -> String -> TrackedErrors [[String]]
forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeFilters [AnyCategory SourceContext]
ts String
"Type<Type<#t>,#b,Type3<#x>,#d,#e,#f>"
        ([String] -> [String] -> TrackedErrors ())
-> [[String]] -> [[String]] -> TrackedErrors ()
forall a.
Show a =>
(a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
checkPaired [String] -> [String] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
containsExactly [[String]]
rs [
            [String
"allows Parent"],
            [String
"requires Type2<Type<#t>>"],
            [String
"defines Equals<Type3<#x>>"],
            [],
            [],
            []
          ]),

    -- TODO: Clean these tests up.
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"Child"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"[Child|Child]"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"[Child&Child]"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"Object2"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"[Object2|Object2]"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"[Object2&Object2]"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeFail CategoryResolver SourceContext
r [] String
"Type<Child>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeFail CategoryResolver SourceContext
r [] String
"[Type<Child>|Type<Child>]"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeFail CategoryResolver SourceContext
r [] String
"[Type<Child>&Type<Child>]"),

    -- TODO: Clean these tests up.
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"Value0<Value1,Value2>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"Value0<Value1,Value1>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r [] String
"Value0<Value3,Value2>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r
          [String
"#x",String
"#y"]
          String
"Value0<#x,#y>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r
          [String
"#x",String
"#y"]
          String
"Value0<#x,#y>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r
          [String
"#x",String
"#y"]
          String
"Value0<#x,Value2>"),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"filters.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
ta <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext]
    -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap
        let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
ta
        CategoryResolver SourceContext
-> [String] -> String -> TrackedErrors ()
forall r.
TypeResolver r =>
r -> [String] -> String -> TrackedErrors ()
checkTypeSuccess CategoryResolver SourceContext
r
          [String
"#x",String
"#y"]
          String
"Value0<#x,#y>"),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"requires_concrete.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts3),

    -- TODO: Clean these tests up.
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"merged.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        [AnyCategory SourceContext]
ts3 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts3
        [String]
rs <- Map CategoryName (AnyCategory SourceContext)
-> String -> TrackedErrors [String]
forall c.
Map CategoryName (AnyCategory c)
-> String -> TrackedErrors [String]
getRefines (CategoryMap SourceContext
-> Map CategoryName (AnyCategory SourceContext)
forall c. CategoryMap c -> Map CategoryName (AnyCategory c)
cmAvailable CategoryMap SourceContext
tm) String
"Test"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` [String
"Value0",String
"Value1",String
"Value2",String
"Value3",
                              String
"Value4<Value1,Value1>",String
"Inherit1",String
"Inherit2"]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"merged.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"duplicate_refine.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"duplicate_define.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"refine_wrong_direction.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"inherit_incompatible.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"merge_incompatible.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"flatten.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        let tm0 :: CategoryMap c
tm0 = [(CategoryName, AnyCategory c)] -> CategoryMap c
forall c. [(CategoryName, AnyCategory c)] -> CategoryMap c
toCategoryMap [
                    (String -> CategoryName
CategoryName String
"Parent2",[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
forall c.
[c]
-> Namespace
-> CategoryName
-> [PragmaCategory c]
-> [ValueParam c]
-> [ScopedFunction c]
-> AnyCategory c
InstanceInterface [] Namespace
NoNamespace (String -> CategoryName
CategoryName String
"Parent2") [] [] [])
                  ]
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
tm0 [AnyCategory SourceContext]
ts
        [String]
rs <- Map CategoryName (AnyCategory SourceContext)
-> String -> TrackedErrors [String]
forall c.
Map CategoryName (AnyCategory c)
-> String -> TrackedErrors [String]
getRefines (CategoryMap SourceContext
-> Map CategoryName (AnyCategory SourceContext)
forall c. CategoryMap c -> Map CategoryName (AnyCategory c)
cmAvailable CategoryMap SourceContext
tm) String
"Child"
        [String]
rs [String] -> [String] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` [String
"Parent<Child>",String
"Object2",
                              String
"Object1<Child,Object3<Object2>>",
                              String
"Object3<Object3<Object2>>"]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"category_function_param_match.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_param_clash.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_duplicate_param.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_bad_filter_param.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_bad_allows_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_bad_requires_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"function_bad_defines_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"weak_arg.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"weak_return.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"function_filters_satisfied.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"function_requires_missed.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"function_allows_missed.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"function_defines_missed.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"valid_function_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"bad_value_arg_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"bad_value_return_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"bad_type_arg_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"bad_type_return_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkCategoryInstances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"valid_filter_variance.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"allows_variance_right.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"defines_variance_right.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"requires_variance_right.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"allows_variance_left.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"defines_variance_left.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"requires_variance_left.0rx")
      (\[AnyCategory SourceContext]
ts -> CategoryMap SourceContext
-> [AnyCategory SourceContext] -> TrackedErrors ()
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m ()
checkParamVariances CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"conflicting_declaration.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"conflicting_inherited.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"successful_merge.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"merge_with_refine.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"failed_merge.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"ambiguous_merge_inherit.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"merge_different_scopes.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"successful_merge_params.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"failed_merge_params.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"preserve_merged.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"conflict_in_preserved.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"resolved_in_preserved.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        [AnyCategory SourceContext]
ts2 <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
topoSortCategories CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity [AnyCategory SourceContext]
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m [AnyCategory c]
flattenAllConnections CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts2 TrackedErrorsT Identity [AnyCategory SourceContext]
-> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ()),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"valid_self.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap ([AnyCategory SourceContext]
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> (CategoryMap SourceContext -> TrackedErrors ())
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> TrackedErrors () -> CategoryMap SourceContext -> TrackedErrors ()
forall a b. a -> b -> a
const (() -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"bad_merge_self.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap ([AnyCategory SourceContext]
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> (CategoryMap SourceContext -> TrackedErrors ())
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> TrackedErrors () -> CategoryMap SourceContext -> TrackedErrors ()
forall a b. a -> b -> a
const (() -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"contravariant_self.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap ([AnyCategory SourceContext]
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> (CategoryMap SourceContext -> TrackedErrors ())
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> TrackedErrors () -> CategoryMap SourceContext -> TrackedErrors ()
forall a b. a -> b -> a
const (() -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail
      (String
"testfiles" String -> String -> String
</> String
"invariant_self.0rx")
      (CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap ([AnyCategory SourceContext]
 -> TrackedErrorsT Identity (CategoryMap SourceContext))
-> (CategoryMap SourceContext -> TrackedErrors ())
-> [AnyCategory SourceContext]
-> TrackedErrors ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> TrackedErrors () -> CategoryMap SourceContext -> TrackedErrors ()
forall a b. a -> b -> a
const (() -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Type1",String
"#x")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Type2",String
"#x"),(String
"Type1",String
"#x")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          []
          []),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface1<Type2>",String
"#x"),(String
"Interface1<Type1>",String
"#x")]
          [(String
"#x",String
"Interface1<Type1>")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<Type2>",String
"#x"),(String
"Interface2<Type1>",String
"#x")]
          [(String
"#x",String
"Interface2<Type2>")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<Type2>",String
"Interface2<#x>"),
           (String
"Interface2<Type1>",String
"Interface2<#x>")]
          [(String
"#x",String
"Type2")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface3<Type1>",String
"#x"),(String
"Interface3<Type1>",String
"#x")]
          [(String
"#x",String
"Interface3<Type1>")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface3<Type1>",String
"#x"),(String
"Interface3<Type2>",String
"#x")]
          [(String
"#x",String
"[Interface3<Type2>|Interface3<Type1>]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface3<Type1>",String
"Interface3<#x>"),
           (String
"Interface3<Type1>",String
"Interface3<#x>")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface3<Type1>",String
"Interface3<#x>"),
           (String
"Interface3<Type2>",String
"Interface3<#x>")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Type1",String
"#x"),
           (String
"Interface1<Type2>",String
"Interface1<#x>"),
           (String
"Interface2<Type0>",String
"Interface2<#x>")]
           [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface3<Type2>",String
"Interface3<#x>"),
           (String
"Interface1<Type2>",String
"Interface1<#x>"),
           (String
"Interface2<Type1>",String
"Interface2<#x>")]
          [(String
"#x",String
"Type2")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface1<Type1>",String
"Interface1<[#x|Interface2<#x>]>")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface1<Type2>",String
"Interface1<[#x&Type1]>")]
          [(String
"#x",String
"Type2")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<Type1>",String
"Interface2<[#x&Interface2<#x>]>")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<Type0>",String
"Interface2<[#x|Type1]>")]
          [(String
"#x",String
"Type0")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- Guesses are both Type0 and Type1, and Type0 is more general.
          [(String
"Interface3<Type0>",String
"[Interface1<#x>&Interface3<#x>]")]
          [(String
"#x",String
"Type0")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- An unrelated union shouldn't cause problems.
          [(String
"Type1",String
"#x"),(String
"Type2",String
"[Type2|Type0]")]
          [(String
"#x",String
"Type1")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[]),(String
"#y",[])] [String
"#x",String
"#y"]
          [(String
"Interface3<Type0>",String
"[Interface1<#x>&Interface3<#x>]"),
           (String
"Interface3<Type0>",String
"[Interface1<#y>|Interface3<#y>]")]
          [(String
"#x",String
"Type0"),(String
"#y",String
"Type1")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface1<any>",String
"Interface1<#x>")]
          [(String
"#x",String
"any")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<all>",String
"Interface2<#x>")]
          [(String
"#x",String
"all")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface1<all>",String
"Interface1<#x>")]
          [(String
"#x",String
"all")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"inference.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"Interface2<any>",String
"Interface2<#x>")]
          [(String
"#x",String
"any")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"delayed_merging.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- Guesses are either Type1 or Type2.
          [(String
"Type",String
"[Interface1<#x>|Interface2<#x>]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"delayed_merging.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- Failure to merge Type1 and Type2 is resolved by Base.
          [(String
"Base",String
"#x"),
           (String
"Type",String
"[Interface1<#x>|Interface2<#x>]")]
          [(String
"#x",String
"Base")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type1>|Interface3<Type2>]",String
"Interface0<#x>")]
          -- Guesses are Type1 and Type2, and Type1 is more general.
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type0>|Interface3<Type4>]",String
"Interface0<#x>")]
          -- Guesses are Type0 and Type4, which can't be merged.
          [(String
"#x",String
"[Type4|Type0]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type1>&Interface3<Type2>]",String
"Interface0<#x>")]
          -- Guesses are Type1 or Type2, and Type2 is more specific.
          [(String
"#x",String
"Type2")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- Guesses are Type0 or Type4, which can't be merged.
          [(String
"[Interface2<Type0>&Interface3<Type4>]",String
"Interface0<#x>")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type1>|Interface3<Type2>]",String
"Interface1<#x>")]
          -- Guesses are Type1 and Type2, and Type2 is more general.
          [(String
"#x",String
"Type2")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type0>|Interface3<Type4>]",String
"Interface1<#x>")]
          -- Guesses are Type0 and Type4, which can't be merged.
          [(String
"#x",String
"[Type4&Type0]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          [(String
"[Interface2<Type1>&Interface3<Type2>]",String
"Interface1<#x>")]
          -- Guesses are Type1 or Type2, and Type1 is more specific.
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm
          [(String
"#x",[])] [String
"#x"]
          -- Guesses are Type0 or Type4, which can't be merged.
          [(String
"[Interface2<Type0>&Interface3<Type4>]",String
"Interface1<#x>")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[String
"requires Type0"])] [String
"#x"]
          -- Guesses are Type1 or Type4, which can't be merged, but the filter
          -- eliminates Type4.
          [(String
"[Interface2<Type1>&Interface3<Type4>]",String
"Interface0<#x>")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[String
"allows Type2"])] [String
"#x"]
          -- Guesses are Type1 or Type4, which can't be merged, but the filter
          -- eliminates Type4.
          [(String
"[Interface2<Type1>&Interface3<Type4>]",String
"Interface0<#x>")]
          [(String
"#x",String
"Type1")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[String
"defines Defined<#x>"])] [String
"#x"]
          -- Guesses are Type1 or Type4, which can't be merged, but the filter
          -- eliminates Type1.
          [(String
"[Interface2<Type1>&Interface3<Type4>]",String
"Interface0<#x>")]
          [(String
"#x",String
"Type4")]),

    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[String
"requires Type0"])] [String
"#x"]
          [(String
"[Type1|Type2]",String
"#x")]
          [(String
"#x",String
"[Type1|Type2]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm
          [(String
"#x",[String
"requires #x"])] [String
"#x"]
          [(String
"[Type1|Type2]",String
"#x")]
          [(String
"#x",String
"[Type1|Type2]")]),
    String
-> ([AnyCategory SourceContext] -> TrackedErrors ())
-> IO (TrackedErrors ())
forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess
      (String
"testfiles" String -> String -> String
</> String
"infer_meta.0rx")
      (\[AnyCategory SourceContext]
ts -> do
        CategoryMap SourceContext
tm <- CategoryMap SourceContext
-> [AnyCategory SourceContext]
-> TrackedErrorsT Identity (CategoryMap SourceContext)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
includeNewTypes CategoryMap SourceContext
forall c. CategoryMap c
emptyCategoryMap [AnyCategory SourceContext]
ts
        CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm
          [(String
"#x",[String
"requires Type0"])] [String
"#x"]
          [(String
"[Type1|Type4]",String
"#x")])
  ]

getRefines :: Map.Map CategoryName (AnyCategory c) -> String -> TrackedErrors [String]
getRefines :: forall c.
Map CategoryName (AnyCategory c)
-> String -> TrackedErrors [String]
getRefines Map CategoryName (AnyCategory c)
tm String
n =
  case (String -> CategoryName
CategoryName String
n) CategoryName
-> Map CategoryName (AnyCategory c) -> Maybe (AnyCategory c)
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` Map CategoryName (AnyCategory c)
tm of
       (Just AnyCategory c
t) -> [String] -> TrackedErrors [String]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> TrackedErrors [String])
-> [String] -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ (ValueRefine c -> String) -> [ValueRefine c] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (TypeInstance -> String
forall a. Show a => a -> String
show (TypeInstance -> String)
-> (ValueRefine c -> TypeInstance) -> ValueRefine c -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueRefine c -> TypeInstance
forall c. ValueRefine c -> TypeInstance
vrType) (AnyCategory c -> [ValueRefine c]
forall c. AnyCategory c -> [ValueRefine c]
getCategoryRefines AnyCategory c
t)
       Maybe (AnyCategory c)
_ -> String -> TrackedErrors [String]
forall a. String -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors [String])
-> String -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ String
"Type " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" not found"

getDefines ::  Map.Map CategoryName (AnyCategory c) -> String -> TrackedErrors [String]
getDefines :: forall c.
Map CategoryName (AnyCategory c)
-> String -> TrackedErrors [String]
getDefines Map CategoryName (AnyCategory c)
tm String
n =
  case (String -> CategoryName
CategoryName String
n) CategoryName
-> Map CategoryName (AnyCategory c) -> Maybe (AnyCategory c)
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` Map CategoryName (AnyCategory c)
tm of
       (Just AnyCategory c
t) -> [String] -> TrackedErrors [String]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> TrackedErrors [String])
-> [String] -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ (ValueDefine c -> String) -> [ValueDefine c] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (DefinesInstance -> String
forall a. Show a => a -> String
show (DefinesInstance -> String)
-> (ValueDefine c -> DefinesInstance) -> ValueDefine c -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueDefine c -> DefinesInstance
forall c. ValueDefine c -> DefinesInstance
vdType) (AnyCategory c -> [ValueDefine c]
forall c. AnyCategory c -> [ValueDefine c]
getCategoryDefines AnyCategory c
t)
       Maybe (AnyCategory c)
_ -> String -> TrackedErrors [String]
forall a. String -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors [String])
-> String -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ String
"Type " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" not found"

getTypeRefines :: Show c => [AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines :: forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeRefines [AnyCategory c]
ts String
s String
n = do
  CategoryMap c
ta <- CategoryMap c
-> [AnyCategory c] -> TrackedErrorsT Identity (CategoryMap c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap c
forall c. CategoryMap c
emptyCategoryMap [AnyCategory c]
ts
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  TypeInstance
t <- String -> String -> TrackedErrors TypeInstance
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s
  Positional [GeneralInstance]
rs <- CategoryResolver c
-> TypeInstance
-> CategoryName
-> TrackedErrorsT Identity InstanceParams
forall r (m :: * -> *).
(TypeResolver r, CollectErrorsM m) =>
r -> TypeInstance -> CategoryName -> m InstanceParams
forall (m :: * -> *).
CollectErrorsM m =>
CategoryResolver c
-> TypeInstance -> CategoryName -> m InstanceParams
trRefines CategoryResolver c
r TypeInstance
t (String -> CategoryName
CategoryName String
n)
  [String] -> TrackedErrors [String]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> TrackedErrors [String])
-> [String] -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ (GeneralInstance -> String) -> [GeneralInstance] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map GeneralInstance -> String
forall a. Show a => a -> String
show [GeneralInstance]
rs

getTypeDefines :: Show c => [AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeDefines :: forall c.
Show c =>
[AnyCategory c] -> String -> String -> TrackedErrors [String]
getTypeDefines [AnyCategory c]
ts String
s String
n = do
  CategoryMap c
ta <- CategoryMap c
-> [AnyCategory c] -> TrackedErrorsT Identity (CategoryMap c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap c
forall c. CategoryMap c
emptyCategoryMap [AnyCategory c]
ts
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  TypeInstance
t <- String -> String -> TrackedErrors TypeInstance
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s
  Positional [GeneralInstance]
ds <- CategoryResolver c
-> TypeInstance
-> CategoryName
-> TrackedErrorsT Identity InstanceParams
forall r (m :: * -> *).
(TypeResolver r, CollectErrorsM m) =>
r -> TypeInstance -> CategoryName -> m InstanceParams
forall (m :: * -> *).
CollectErrorsM m =>
CategoryResolver c
-> TypeInstance -> CategoryName -> m InstanceParams
trDefines CategoryResolver c
r TypeInstance
t (String -> CategoryName
CategoryName String
n)
  [String] -> TrackedErrors [String]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([String] -> TrackedErrors [String])
-> [String] -> TrackedErrors [String]
forall a b. (a -> b) -> a -> b
$ (GeneralInstance -> String) -> [GeneralInstance] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map GeneralInstance -> String
forall a. Show a => a -> String
show [GeneralInstance]
ds

getTypeVariance :: Show c => [AnyCategory c] -> String -> TrackedErrors [Variance]
getTypeVariance :: forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [Variance]
getTypeVariance [AnyCategory c]
ts String
n = do
  CategoryMap c
ta <- CategoryMap c
-> [AnyCategory c] -> TrackedErrorsT Identity (CategoryMap c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap c
forall c. CategoryMap c
emptyCategoryMap [AnyCategory c]
ts
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  (Positional [Variance]
vs) <- CategoryResolver c
-> CategoryName -> TrackedErrorsT Identity (Positional Variance)
forall r (m :: * -> *).
(TypeResolver r, CollectErrorsM m) =>
r -> CategoryName -> m (Positional Variance)
forall (m :: * -> *).
CollectErrorsM m =>
CategoryResolver c -> CategoryName -> m (Positional Variance)
trVariance CategoryResolver c
r (String -> CategoryName
CategoryName String
n)
  [Variance] -> TrackedErrors [Variance]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return [Variance]
vs

getTypeFilters :: Show c => [AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeFilters :: forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeFilters [AnyCategory c]
ts String
s = do
  CategoryMap c
ta <- CategoryMap c
-> [AnyCategory c] -> TrackedErrorsT Identity (CategoryMap c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap c
forall c. CategoryMap c
emptyCategoryMap [AnyCategory c]
ts
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  TypeInstance
t <- String -> String -> TrackedErrors TypeInstance
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s
  Positional [[TypeFilter]]
vs <- CategoryResolver c
-> TypeInstance
-> TrackedErrorsT Identity (Positional [TypeFilter])
forall r (m :: * -> *).
(TypeResolver r, CollectErrorsM m) =>
r -> TypeInstance -> m (Positional [TypeFilter])
forall (m :: * -> *).
CollectErrorsM m =>
CategoryResolver c -> TypeInstance -> m (Positional [TypeFilter])
trTypeFilters CategoryResolver c
r TypeInstance
t
  [[String]] -> TrackedErrors [[String]]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([[String]] -> TrackedErrors [[String]])
-> [[String]] -> TrackedErrors [[String]]
forall a b. (a -> b) -> a -> b
$ ([TypeFilter] -> [String]) -> [[TypeFilter]] -> [[String]]
forall a b. (a -> b) -> [a] -> [b]
map ((TypeFilter -> String) -> [TypeFilter] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map TypeFilter -> String
forall a. Show a => a -> String
show) [[TypeFilter]]
vs

getTypeDefinesFilters :: Show c => [AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeDefinesFilters :: forall c.
Show c =>
[AnyCategory c] -> String -> TrackedErrors [[String]]
getTypeDefinesFilters [AnyCategory c]
ts String
s = do
  CategoryMap c
ta <- CategoryMap c
-> [AnyCategory c] -> TrackedErrorsT Identity (CategoryMap c)
forall c (m :: * -> *).
(Show c, CollectErrorsM m) =>
CategoryMap c -> [AnyCategory c] -> m (CategoryMap c)
declareAllTypes CategoryMap c
forall c. CategoryMap c
emptyCategoryMap [AnyCategory c]
ts
  let r :: CategoryResolver c
r = CategoryMap c -> CategoryResolver c
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap c
ta
  DefinesInstance
t <- String -> String -> TrackedErrors DefinesInstance
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s
  Positional [[TypeFilter]]
vs <- CategoryResolver c
-> DefinesInstance
-> TrackedErrorsT Identity (Positional [TypeFilter])
forall r (m :: * -> *).
(TypeResolver r, CollectErrorsM m) =>
r -> DefinesInstance -> m (Positional [TypeFilter])
forall (m :: * -> *).
CollectErrorsM m =>
CategoryResolver c
-> DefinesInstance -> m (Positional [TypeFilter])
trDefinesFilters CategoryResolver c
r DefinesInstance
t
  [[String]] -> TrackedErrors [[String]]
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ([[String]] -> TrackedErrors [[String]])
-> [[String]] -> TrackedErrors [[String]]
forall a b. (a -> b) -> a -> b
$ ([TypeFilter] -> [String]) -> [[TypeFilter]] -> [[String]]
forall a b. (a -> b) -> [a] -> [b]
map ((TypeFilter -> String) -> [TypeFilter] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map TypeFilter -> String
forall a. Show a => a -> String
show) [[TypeFilter]]
vs

scrapeAllRefines :: [AnyCategory c] -> [(String, String)]
scrapeAllRefines :: forall c. [AnyCategory c] -> [(String, String)]
scrapeAllRefines = ((CategoryName, TypeInstance) -> (String, String))
-> [(CategoryName, TypeInstance)] -> [(String, String)]
forall a b. (a -> b) -> [a] -> [b]
map (CategoryName -> String
forall a. Show a => a -> String
show (CategoryName -> String)
-> (TypeInstance -> String)
-> (CategoryName, TypeInstance)
-> (String, String)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** TypeInstance -> String
forall a. Show a => a -> String
show) ([(CategoryName, TypeInstance)] -> [(String, String)])
-> ([AnyCategory c] -> [(CategoryName, TypeInstance)])
-> [AnyCategory c]
-> [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[(CategoryName, TypeInstance)]] -> [(CategoryName, TypeInstance)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(CategoryName, TypeInstance)]]
 -> [(CategoryName, TypeInstance)])
-> ([AnyCategory c] -> [[(CategoryName, TypeInstance)]])
-> [AnyCategory c]
-> [(CategoryName, TypeInstance)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AnyCategory c -> [(CategoryName, TypeInstance)])
-> [AnyCategory c] -> [[(CategoryName, TypeInstance)]]
forall a b. (a -> b) -> [a] -> [b]
map AnyCategory c -> [(CategoryName, TypeInstance)]
forall {c}. AnyCategory c -> [(CategoryName, TypeInstance)]
scrapeSingle where
  scrapeSingle :: AnyCategory c -> [(CategoryName, TypeInstance)]
scrapeSingle (ValueInterface [c]
_ Namespace
_ CategoryName
n [PragmaCategory c]
_ [ValueParam c]
_ [ValueRefine c]
rs [ScopedFunction c]
_)      = (ValueRefine c -> (CategoryName, TypeInstance))
-> [ValueRefine c] -> [(CategoryName, TypeInstance)]
forall a b. (a -> b) -> [a] -> [b]
map ((,) CategoryName
n (TypeInstance -> (CategoryName, TypeInstance))
-> (ValueRefine c -> TypeInstance)
-> ValueRefine c
-> (CategoryName, TypeInstance)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueRefine c -> TypeInstance
forall c. ValueRefine c -> TypeInstance
vrType) [ValueRefine c]
rs
  scrapeSingle (ValueConcrete [c]
_ Namespace
_ CategoryName
n [PragmaCategory c]
_ [FunctionVisibility c]
_ [ValueParam c]
_ [ValueRefine c]
rs [ValueDefine c]
_ [ParamFilter c]
_ [ScopedFunction c]
_) = (ValueRefine c -> (CategoryName, TypeInstance))
-> [ValueRefine c] -> [(CategoryName, TypeInstance)]
forall a b. (a -> b) -> [a] -> [b]
map ((,) CategoryName
n (TypeInstance -> (CategoryName, TypeInstance))
-> (ValueRefine c -> TypeInstance)
-> ValueRefine c
-> (CategoryName, TypeInstance)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueRefine c -> TypeInstance
forall c. ValueRefine c -> TypeInstance
vrType) [ValueRefine c]
rs
  scrapeSingle AnyCategory c
_ = []

scrapeAllDefines :: [AnyCategory c] -> [(String, String)]
scrapeAllDefines :: forall c. [AnyCategory c] -> [(String, String)]
scrapeAllDefines = ((CategoryName, DefinesInstance) -> (String, String))
-> [(CategoryName, DefinesInstance)] -> [(String, String)]
forall a b. (a -> b) -> [a] -> [b]
map (CategoryName -> String
forall a. Show a => a -> String
show (CategoryName -> String)
-> (DefinesInstance -> String)
-> (CategoryName, DefinesInstance)
-> (String, String)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** DefinesInstance -> String
forall a. Show a => a -> String
show) ([(CategoryName, DefinesInstance)] -> [(String, String)])
-> ([AnyCategory c] -> [(CategoryName, DefinesInstance)])
-> [AnyCategory c]
-> [(String, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[(CategoryName, DefinesInstance)]]
-> [(CategoryName, DefinesInstance)]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[(CategoryName, DefinesInstance)]]
 -> [(CategoryName, DefinesInstance)])
-> ([AnyCategory c] -> [[(CategoryName, DefinesInstance)]])
-> [AnyCategory c]
-> [(CategoryName, DefinesInstance)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (AnyCategory c -> [(CategoryName, DefinesInstance)])
-> [AnyCategory c] -> [[(CategoryName, DefinesInstance)]]
forall a b. (a -> b) -> [a] -> [b]
map AnyCategory c -> [(CategoryName, DefinesInstance)]
forall {c}. AnyCategory c -> [(CategoryName, DefinesInstance)]
scrapeSingle where
  scrapeSingle :: AnyCategory c -> [(CategoryName, DefinesInstance)]
scrapeSingle (ValueConcrete [c]
_ Namespace
_ CategoryName
n [PragmaCategory c]
_ [FunctionVisibility c]
_ [ValueParam c]
_ [ValueRefine c]
_ [ValueDefine c]
ds [ParamFilter c]
_ [ScopedFunction c]
_) = (ValueDefine c -> (CategoryName, DefinesInstance))
-> [ValueDefine c] -> [(CategoryName, DefinesInstance)]
forall a b. (a -> b) -> [a] -> [b]
map ((,) CategoryName
n (DefinesInstance -> (CategoryName, DefinesInstance))
-> (ValueDefine c -> DefinesInstance)
-> ValueDefine c
-> (CategoryName, DefinesInstance)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ValueDefine c -> DefinesInstance
forall c. ValueDefine c -> DefinesInstance
vdType) [ValueDefine c]
ds
  scrapeSingle AnyCategory c
_ = []

checkPaired :: Show a => (a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
checkPaired :: forall a.
Show a =>
(a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
checkPaired a -> a -> TrackedErrors ()
f [a]
actual [a]
expected
  | [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
actual Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
expected =
    String -> TrackedErrors ()
forall a. String -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Different item counts: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [a] -> String
forall a. Show a => a -> String
show [a]
actual String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (actual) vs. " String -> String -> String
forall a. [a] -> [a] -> [a]
++
                   [a] -> String
forall a. Show a => a -> String
show [a]
expected String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (expected)"
  | Bool
otherwise = ((a, a, Int) -> TrackedErrors ())
-> [(a, a, Int)] -> TrackedErrors ()
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m ()
mapCompilerM_ (a, a, Int) -> TrackedErrors ()
forall {a}. Show a => (a, a, a) -> TrackedErrors ()
check ([a] -> [a] -> [Int] -> [(a, a, Int)]
forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
zip3 [a]
actual [a]
expected ([Int
1..] :: [Int])) where
    check :: (a, a, a) -> TrackedErrors ()
check (a
a,a
e,a
n) = a -> a -> TrackedErrors ()
f a
a a
e TrackedErrors () -> String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
<!! String
"Item " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" mismatch"

containsPaired :: (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
containsPaired :: forall a. (Eq a, Show a) => [a] -> [a] -> TrackedErrors ()
containsPaired = (a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
forall a.
Show a =>
(a -> a -> TrackedErrors ()) -> [a] -> [a] -> TrackedErrors ()
checkPaired a -> a -> TrackedErrors ()
forall {a} {m :: * -> *}.
(Eq a, ErrorContextM m, Show a) =>
a -> a -> m ()
checkSingle where
  checkSingle :: a -> a -> m ()
checkSingle a
a a
e
    | a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
e = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    | Bool
otherwise = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ a -> String
forall a. Show a => a -> String
show a
a String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (actual) vs. " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (expected)"

checkOperationSuccess :: String -> ([AnyCategory SourceContext] -> TrackedErrors a) -> IO (TrackedErrors ())
checkOperationSuccess :: forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationSuccess String
f [AnyCategory SourceContext] -> TrackedErrors a
o = do
  String
contents <- String -> IO String
loadFile String
f
  let parsed :: TrackedErrorsT Identity [AnyCategory SourceContext]
parsed = String
-> String -> TrackedErrorsT Identity [AnyCategory SourceContext]
forall a.
ParseFromSource a =>
String -> String -> TrackedErrors [a]
readMulti String
f String
contents :: TrackedErrors [AnyCategory SourceContext]
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors () -> TrackedErrors ()
forall {m :: * -> *} {a}. ErrorContextM m => m a -> m a
check (TrackedErrorsT Identity [AnyCategory SourceContext]
parsed TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> TrackedErrors a
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [AnyCategory SourceContext] -> TrackedErrors a
o TrackedErrors a -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  where
    check :: m a -> m a
check m a
x = m a
x m a -> String -> m a
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
<!! String
"Check " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":"

checkOperationFailWith :: String -> String -> ([AnyCategory SourceContext] -> TrackedErrors a) -> IO (TrackedErrors ())
checkOperationFailWith :: forall a.
String
-> String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFailWith String
m String
f [AnyCategory SourceContext] -> TrackedErrors a
o = do
  String
contents <- String -> IO String
loadFile String
f
  let parsed :: TrackedErrorsT Identity [AnyCategory SourceContext]
parsed = String
-> String -> TrackedErrorsT Identity [AnyCategory SourceContext]
forall a.
ParseFromSource a =>
String -> String -> TrackedErrors [a]
readMulti String
f String
contents :: TrackedErrors [AnyCategory SourceContext]
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors () -> TrackedErrors ()
forall {f :: * -> *} {a}.
(ErrorContextM f, Show a) =>
TrackedErrorsT Identity a -> f ()
check (TrackedErrorsT Identity [AnyCategory SourceContext]
parsed TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> TrackedErrors a
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [AnyCategory SourceContext] -> TrackedErrors a
o TrackedErrors a -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  where
    check :: TrackedErrorsT Identity a -> f ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = do
          let text :: String
text = CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrorsT Identity a
c)
          Bool -> f () -> f ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ String
text String -> String -> Bool
forall source source1 target.
(RegexMaker Regex CompOption ExecOption source,
 RegexContext Regex source1 target) =>
source1 -> source -> target
=~ String
m) (f () -> f ()) -> f () -> f ()
forall a b. (a -> b) -> a -> b
$
            String -> f ()
forall a. String -> f a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> f ()) -> String -> f ()
forall a b. (a -> b) -> a -> b
$ String
"Expected pattern " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" in error output but got\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
text
      | Bool
otherwise = String -> f ()
forall a. String -> f a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> f ()) -> String -> f ()
forall a b. (a -> b) -> a -> b
$ String
"Check " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": Expected failure but got\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                     a -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrorsT Identity a
c) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n"

checkOperationFail :: String -> ([AnyCategory SourceContext] -> TrackedErrors a) -> IO (TrackedErrors ())
checkOperationFail :: forall a.
String
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> IO (TrackedErrors ())
checkOperationFail String
f [AnyCategory SourceContext] -> TrackedErrors a
o = do
  String
contents <- String -> IO String
loadFile String
f
  let parsed :: TrackedErrorsT Identity [AnyCategory SourceContext]
parsed = String
-> String -> TrackedErrorsT Identity [AnyCategory SourceContext]
forall a.
ParseFromSource a =>
String -> String -> TrackedErrors [a]
readMulti String
f String
contents :: TrackedErrors [AnyCategory SourceContext]
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors () -> TrackedErrors ()
forall {f :: * -> *} {a}.
(ErrorContextM f, Show a) =>
TrackedErrorsT Identity a -> f ()
check (TrackedErrorsT Identity [AnyCategory SourceContext]
parsed TrackedErrorsT Identity [AnyCategory SourceContext]
-> ([AnyCategory SourceContext] -> TrackedErrors a)
-> TrackedErrors a
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [AnyCategory SourceContext] -> TrackedErrors a
o TrackedErrors a -> TrackedErrors () -> TrackedErrors ()
forall a b.
TrackedErrorsT Identity a
-> TrackedErrorsT Identity b -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return ())
  where
    check :: TrackedErrorsT Identity a -> m ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Check " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": Expected failure but got\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                   a -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrorsT Identity a
c) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n"

checkSingleParseSuccess :: String -> IO (TrackedErrors ())
checkSingleParseSuccess :: String -> IO (TrackedErrors ())
checkSingleParseSuccess String
f = do
  String
contents <- String -> IO String
loadFile String
f
  let parsed :: TrackedErrors (AnyCategory SourceContext)
parsed = String -> String -> TrackedErrors (AnyCategory SourceContext)
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
f String
contents :: TrackedErrors (AnyCategory SourceContext)
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors (AnyCategory SourceContext) -> TrackedErrors ()
forall {m :: * -> *} {a}.
ErrorContextM m =>
TrackedErrorsT Identity a -> m ()
check TrackedErrors (AnyCategory SourceContext)
parsed
  where
    check :: TrackedErrorsT Identity a -> m ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Parse " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrorsT Identity a
c)
      | Bool
otherwise = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

checkSingleParseFail :: String -> IO (TrackedErrors ())
checkSingleParseFail :: String -> IO (TrackedErrors ())
checkSingleParseFail String
f = do
  String
contents <- String -> IO String
loadFile String
f
  let parsed :: TrackedErrors (AnyCategory SourceContext)
parsed = String -> String -> TrackedErrors (AnyCategory SourceContext)
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
f String
contents :: TrackedErrors (AnyCategory SourceContext)
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors (AnyCategory SourceContext) -> TrackedErrors ()
forall {f :: * -> *} {a}.
(ErrorContextM f, Show a) =>
TrackedErrorsT Identity a -> f ()
check TrackedErrors (AnyCategory SourceContext)
parsed
  where
    check :: TrackedErrorsT Identity a -> m ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Parse " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
f String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": Expected failure but got\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                   a -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrorsT Identity a
c) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n"

checkShortParseSuccess :: String -> IO (TrackedErrors ())
checkShortParseSuccess :: String -> IO (TrackedErrors ())
checkShortParseSuccess String
s = do
  let parsed :: TrackedErrors (AnyCategory SourceContext)
parsed = String -> String -> TrackedErrors (AnyCategory SourceContext)
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s :: TrackedErrors (AnyCategory SourceContext)
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors (AnyCategory SourceContext) -> TrackedErrors ()
forall {m :: * -> *} {a}.
ErrorContextM m =>
TrackedErrorsT Identity a -> m ()
check TrackedErrors (AnyCategory SourceContext)
parsed
  where
    check :: TrackedErrorsT Identity a -> m ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Parse '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"':\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrorsT Identity a
c)
      | Bool
otherwise = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

checkShortParseFail :: String -> IO (TrackedErrors ())
checkShortParseFail :: String -> IO (TrackedErrors ())
checkShortParseFail String
s = do
  let parsed :: TrackedErrors (AnyCategory SourceContext)
parsed = String -> String -> TrackedErrors (AnyCategory SourceContext)
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
s :: TrackedErrors (AnyCategory SourceContext)
  TrackedErrors () -> IO (TrackedErrors ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors (AnyCategory SourceContext) -> TrackedErrors ()
forall {f :: * -> *} {a}.
(ErrorContextM f, Show a) =>
TrackedErrorsT Identity a -> f ()
check TrackedErrors (AnyCategory SourceContext)
parsed
  where
    check :: TrackedErrorsT Identity a -> m ()
check TrackedErrorsT Identity a
c
      | TrackedErrorsT Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity a
c = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
      | Bool
otherwise = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
"Parse '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
s String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"': Expected failure but got\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++
                                   a -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrorsT Identity a
c) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n"

checkInferenceSuccess :: CategoryMap SourceContext -> [(String, [String])] ->
  [String] -> [(String,String)] -> [(String,String)] -> TrackedErrors ()
checkInferenceSuccess :: CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceSuccess CategoryMap SourceContext
tm [(String, [String])]
pa [String]
is [(String, String)]
ts [(String, String)]
gs = (ParamValues -> TrackedErrors ParamValues -> TrackedErrors ())
-> CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceCommon ParamValues -> TrackedErrors ParamValues -> TrackedErrors ()
forall {k} {a}.
(Ord k, Ord a, Show k, Show a) =>
Map k a -> TrackedErrorsT Identity (Map k a) -> TrackedErrors ()
check CategoryMap SourceContext
tm [(String, [String])]
pa [String]
is [(String, String)]
ts [(String, String)]
gs where
  prefix :: String
prefix = [(String, String)] -> String
forall a. Show a => a -> String
show [(String, String)]
ts String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [(String, [String])] -> String
showFilters [(String, [String])]
pa
  check :: Map k a -> TrackedErrorsT Identity (Map k a) -> TrackedErrors ()
check Map k a
gs2 TrackedErrorsT Identity (Map k a)
c
    | TrackedErrorsT Identity (Map k a) -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrorsT Identity (Map k a)
c = String -> TrackedErrors ()
forall a. String -> TrackedErrorsT Identity a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity (Map k a) -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrorsT Identity (Map k a)
c) String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrorsT Identity (Map k a) -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrorsT Identity (Map k a)
c)
    | Bool
otherwise         = (Map k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
Map.toList (Map k a -> [(k, a)]) -> Map k a -> [(k, a)]
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT Identity (Map k a) -> Map k a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrorsT Identity (Map k a)
c) [(k, a)] -> [(k, a)] -> TrackedErrors ()
forall a. (Ord a, Show a) => [a] -> [a] -> TrackedErrors ()
`containsExactly` Map k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
Map.toList Map k a
gs2

checkInferenceFail :: CategoryMap SourceContext -> [(String, [String])] ->
  [String] -> [(String,String)] -> TrackedErrors ()
checkInferenceFail :: CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceFail CategoryMap SourceContext
tm [(String, [String])]
pa [String]
is [(String, String)]
ts = (ParamValues -> TrackedErrors ParamValues -> TrackedErrors ())
-> CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceCommon ParamValues -> TrackedErrors ParamValues -> TrackedErrors ()
forall {t :: (* -> *) -> * -> *} {m :: * -> *} {p} {a}.
(ErrorContextT t, ErrorContextM m, ErrorContextM (t Identity)) =>
p -> t Identity a -> m ()
check CategoryMap SourceContext
tm [(String, [String])]
pa [String]
is [(String, String)]
ts [] where
  prefix :: String
prefix = [(String, String)] -> String
forall a. Show a => a -> String
show [(String, String)]
ts String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [(String, [String])] -> String
showFilters [(String, [String])]
pa
  check :: p -> t Identity a -> m ()
check p
_ t Identity a
c
    | t Identity a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError t Identity a
c = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    | Bool
otherwise         = String -> m ()
forall a. String -> m a
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> m ()) -> String -> m ()
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
": Expected failure\n"

checkInferenceCommon :: (ParamValues -> TrackedErrors ParamValues -> TrackedErrors ()) ->
  CategoryMap SourceContext -> [(String,[String])] -> [String] ->
  [(String,String)] -> [(String,String)] -> TrackedErrors ()
checkInferenceCommon :: (ParamValues -> TrackedErrors ParamValues -> TrackedErrors ())
-> CategoryMap SourceContext
-> [(String, [String])]
-> [String]
-> [(String, String)]
-> [(String, String)]
-> TrackedErrors ()
checkInferenceCommon ParamValues -> TrackedErrors ParamValues -> TrackedErrors ()
check CategoryMap SourceContext
tm [(String, [String])]
pa [String]
is [(String, String)]
ts [(String, String)]
gs = TrackedErrors ()
checked TrackedErrors () -> String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
<!! String
context where
  context :: String
context = String
"With params = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [(String, [String])] -> String
forall a. Show a => a -> String
show [(String, [String])]
pa String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", pairs = " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [(String, String)] -> String
forall a. Show a => a -> String
show [(String, String)]
ts
  checked :: TrackedErrors ()
checked = do
    let r :: CategoryResolver SourceContext
r = CategoryMap SourceContext -> CategoryResolver SourceContext
forall c. CategoryMap c -> CategoryResolver c
CategoryResolver CategoryMap SourceContext
tm
    ParamFilters
pa2 <- [(String, [String])] -> TrackedErrors ParamFilters
parseFilterMap [(String, [String])]
pa
    ParamValues
ia2 <- ([(ParamName, GeneralInstance)] -> ParamValues)
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
-> TrackedErrors ParamValues
forall a b.
(a -> b) -> TrackedErrorsT Identity a -> TrackedErrorsT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(ParamName, GeneralInstance)] -> ParamValues
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (TrackedErrorsT Identity [(ParamName, GeneralInstance)]
 -> TrackedErrors ParamValues)
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
-> TrackedErrors ParamValues
forall a b. (a -> b) -> a -> b
$ (String -> TrackedErrorsT Identity (ParamName, GeneralInstance))
-> [String]
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM String -> TrackedErrorsT Identity (ParamName, GeneralInstance)
readInferred [String]
is
    [PatternMatch]
ts2 <- ((String, String) -> TrackedErrorsT Identity PatternMatch)
-> [(String, String)] -> TrackedErrorsT Identity [PatternMatch]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM (ParamValues
-> Variance
-> (String, String)
-> TrackedErrorsT Identity PatternMatch
parsePair ParamValues
ia2 Variance
Covariant) [(String, String)]
ts
    let ka :: Set ParamName
ka = ParamValues -> Set ParamName
forall k a. Map k a -> Set k
Map.keysSet ParamValues
ia2
    ParamValues
gs' <- ([(ParamName, GeneralInstance)] -> ParamValues)
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
-> TrackedErrors ParamValues
forall a b.
(a -> b) -> TrackedErrorsT Identity a -> TrackedErrorsT Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(ParamName, GeneralInstance)] -> ParamValues
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (TrackedErrorsT Identity [(ParamName, GeneralInstance)]
 -> TrackedErrors ParamValues)
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
-> TrackedErrors ParamValues
forall a b. (a -> b) -> a -> b
$ ((String, String)
 -> TrackedErrorsT Identity (ParamName, GeneralInstance))
-> [(String, String)]
-> TrackedErrorsT Identity [(ParamName, GeneralInstance)]
forall (m :: * -> *) a b.
CollectErrorsM m =>
(a -> m b) -> [a] -> m [b]
mapCompilerM (String, String)
-> TrackedErrorsT Identity (ParamName, GeneralInstance)
forall {a} {b}.
(ParseFromSource a, ParseFromSource b) =>
(String, String) -> TrackedErrorsT Identity (a, b)
parseGuess [(String, String)]
gs
    let f :: ParamFilters
f  = (ParamName -> [TypeFilter] -> Bool) -> ParamFilters -> ParamFilters
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (\ParamName
k [TypeFilter]
_ -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ ParamName
k ParamName -> Set ParamName -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set ParamName
ka) ParamFilters
pa2
    let ff :: ParamFilters
ff = (ParamName -> [TypeFilter] -> Bool) -> ParamFilters -> ParamFilters
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Map.filterWithKey (\ParamName
k [TypeFilter]
_ -> ParamName
k ParamName -> Set ParamName -> Bool
forall a. Ord a => a -> Set a -> Bool
`Set.member` Set ParamName
ka) ParamFilters
pa2
    MergeTree InferredTypeGuess
gs2 <- CategoryResolver SourceContext
-> ParamFilters
-> ParamValues
-> [PatternMatch]
-> TrackedErrorsT Identity (MergeTree InferredTypeGuess)
forall (m :: * -> *) r.
(CollectErrorsM m, TypeResolver r) =>
r
-> ParamFilters
-> ParamValues
-> [PatternMatch]
-> m (MergeTree InferredTypeGuess)
inferParamTypes CategoryResolver SourceContext
r ParamFilters
f ParamValues
ia2 [PatternMatch]
ts2
    ParamValues -> TrackedErrors ParamValues -> TrackedErrors ()
check ParamValues
gs' (TrackedErrors ParamValues -> TrackedErrors ())
-> TrackedErrors ParamValues -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ CategoryResolver SourceContext
-> ParamFilters
-> ParamFilters
-> ParamValues
-> MergeTree InferredTypeGuess
-> TrackedErrors ParamValues
forall (m :: * -> *) r.
(CollectErrorsM m, TypeResolver r) =>
r
-> ParamFilters
-> ParamFilters
-> ParamValues
-> MergeTree InferredTypeGuess
-> m ParamValues
mergeInferredTypes CategoryResolver SourceContext
r ParamFilters
f ParamFilters
ff ParamValues
ia2 MergeTree InferredTypeGuess
gs2
  readInferred :: String -> TrackedErrorsT Identity (ParamName, GeneralInstance)
readInferred String
p = do
    ParamName
p' <- String -> String -> TrackedErrors ParamName
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
p
    (ParamName, GeneralInstance)
-> TrackedErrorsT Identity (ParamName, GeneralInstance)
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (ParamName
p',TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType (TypeInstanceOrParam -> GeneralInstance)
-> TypeInstanceOrParam -> GeneralInstance
forall a b. (a -> b) -> a -> b
$ ParamName -> TypeInstanceOrParam
JustInferredType ParamName
p')
  parseGuess :: (String, String) -> TrackedErrorsT Identity (a, b)
parseGuess (String
p,String
t) = do
    a
p' <- String -> String -> TrackedErrors a
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
p
    b
t' <- String -> String -> TrackedErrors b
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
t
    (a, b) -> TrackedErrorsT Identity (a, b)
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
p',b
t')
  parsePair :: ParamValues
-> Variance
-> (String, String)
-> TrackedErrorsT Identity PatternMatch
parsePair ParamValues
im Variance
v (String
t1,String
t2) = do
    ValueType
t1' <- String -> String -> TrackedErrors ValueType
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
t1
    ValueType
t2' <- String -> String -> TrackedErrors ValueType
forall a. ParseFromSource a => String -> String -> TrackedErrors a
readSingle String
"(string)" String
t2 TrackedErrors ValueType
-> (ValueType -> TrackedErrors ValueType)
-> TrackedErrors ValueType
forall a b.
TrackedErrorsT Identity a
-> (a -> TrackedErrorsT Identity b) -> TrackedErrorsT Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ParamName -> TrackedErrorsT Identity GeneralInstance)
-> ValueType -> TrackedErrors ValueType
forall (m :: * -> *).
CollectErrorsM m =>
(ParamName -> m GeneralInstance) -> ValueType -> m ValueType
uncheckedSubValueType (ParamValues -> ParamName -> TrackedErrorsT Identity GeneralInstance
forall {m :: * -> *}.
Monad m =>
ParamValues -> ParamName -> m GeneralInstance
weakLookup ParamValues
im)
    PatternMatch -> TrackedErrorsT Identity PatternMatch
forall a. a -> TrackedErrorsT Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Variance -> ValueType -> ValueType -> PatternMatch
TypePattern Variance
v ValueType
t1' ValueType
t2')
  weakLookup :: ParamValues -> ParamName -> m GeneralInstance
weakLookup ParamValues
tm2 ParamName
n =
    case ParamName
n ParamName -> ParamValues -> Maybe GeneralInstance
forall k a. Ord k => k -> Map k a -> Maybe a
`Map.lookup` ParamValues
tm2 of
         Just GeneralInstance
t  -> GeneralInstance -> m GeneralInstance
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return GeneralInstance
t
         Maybe GeneralInstance
Nothing -> GeneralInstance -> m GeneralInstance
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (GeneralInstance -> m GeneralInstance)
-> GeneralInstance -> m GeneralInstance
forall a b. (a -> b) -> a -> b
$ TypeInstanceOrParam -> GeneralInstance
forall a. (Eq a, Ord a) => a -> GeneralType a
singleType (TypeInstanceOrParam -> GeneralInstance)
-> TypeInstanceOrParam -> GeneralInstance
forall a b. (a -> b) -> a -> b
$ Bool -> ParamName -> TypeInstanceOrParam
JustParamName Bool
True ParamName
n