public static void AssertNode(this ITicResults results, ITypeState type, params int[] nodeIds)
{
foreach (var id in nodeIds)
{
Assert.AreEqual(type, results.GetSyntaxNodeOrNull(id).GetNonReference().State);
}
}
public static void AssertNode(this ITicResults results, TicNode generic, params int[] nodeIds)
{
foreach (var id in nodeIds)
{
Assert.AreEqual(generic.GetNonReference(), results.GetSyntaxNodeOrNull(id).GetNonReference());
}
}
public static void AssertNamed(this ITicResults results, ITypeState type, params string[] varNames)
{
foreach (var varName in varNames)
{
Assert.AreEqual(type, results.GetVariableNode(varName).GetNonReference().State);
}
}
public static void AssertAreGenerics(this ITicResults result, TicNode targetGenericNode,
params string[] varNames)
{
foreach (var varName in varNames)
{
Assert.AreEqual(targetGenericNode, result.GetVariableNode(varName).GetNonReference());
}
}
public static void AssertNode(this ITicResults results, ITypeState type, params int[] nodeIds)
{
foreach (var id in nodeIds)
{
var actual = results.GetSyntaxNodeOrNull(id).State;
AssertNodeStateEqualToState(type, actual, id);
}
}
public static TicNode AssertAndGetSingleGeneric(this ITicResults result, StatePrimitive desc,
StatePrimitive anc, bool isComparable = false)
{
Assert.AreEqual(1, result.GenericsCount, "Incorrect generics count");
var genericNode = result.GenericNodes.Single();
AssertGenericType(genericNode, desc, anc, isComparable);
return(genericNode);
}
public static void AssertNamed(this ITicResults results, ITypeState expectedState, params string[] varNames)
{
foreach (var varName in varNames)
{
AssertNodeStateEqualToState(
expected: expectedState,
actual: results.GetVariableNode(varName).State,
id: varName);
}
}
public TypeInferenceResults(
ITicResults bodyTypeSolving,
StateRefTo[][] genericFunctionTypes,
IList <IFunctionSignature> functionalVariables,
IList <StateFun> recursiveCalls)
{
GenericFunctionTypes = genericFunctionTypes;
_bodyTypeSolving = bodyTypeSolving;
_functionalVariables = functionalVariables;
_recursiveCalls = recursiveCalls;
}
public static void AssertNamedEqualToArrayOf(this ITicResults results, object typeOrNode, params string[] varNames)
{
foreach (var varName in varNames)
{
var node = results.GetVariableNode(varName).GetNonReference();
if (node.State is StateArray array)
{
var element = array.ElementNode;
if (typeOrNode is StatePrimitive concrete)
{
Assert.IsTrue(concrete.Equals(element.State));
}
else
{
Assert.AreEqual(typeOrNode, array.ElementNode);
}
}
else
{
Assert.Fail();
}
}
}
public static void AssertNoGenerics(this ITicResults results) => Assert.IsFalse(results.HasGenerics, "Unexpected generic types");
public static TicNode AssertAndGetSingleArithGeneric(this ITicResults result) => AssertAndGetSingleGeneric(result, StatePrimitive.U24, StatePrimitive.Real, false);
public static void AssertNoGenerics(this ITicResults results) => Assert.AreEqual(0, results.GenericsCount, "Unexpected generic types");
