public void GetMergedStateOrNull_EmptyAndNonEmptyStruct()
{
var nonEmpty = new StateStruct(
new Dictionary <string, TicNode>
{
{ "i", TicNode.CreateTypeVariableNode(StatePrimitive.I32) },
{ "r", TicNode.CreateTypeVariableNode(StatePrimitive.Real) }
}
);
var res = SolvingFunctions.GetMergedStateOrNull(
nonEmpty,
new StateStruct());
var expected = new StateStruct(
new Dictionary <string, TicNode>
{
{ "i", TicNode.CreateTypeVariableNode(StatePrimitive.I32) },
{ "r", TicNode.CreateTypeVariableNode(StatePrimitive.Real) }
});
Assert.AreEqual(res, expected);
var invertedres = SolvingFunctions.GetMergedStateOrNull(
new StateStruct(), nonEmpty);
Assert.AreEqual(res, invertedres);
}
public void SeveralStrictStructMembers()
{
// 0 2 1
//y:int = a . name
// 3 5 4
//z:real = a . age
var graph = new GraphBuilder();
graph.SetVar("a", 0);
graph.SetFieldAccess(0, 2, "name");
graph.SetVarType("y", StatePrimitive.I32);
graph.SetDef("y", 2);
graph.SetVar("a", 3);
graph.SetFieldAccess(3, 5, "age");
graph.SetVarType("z", StatePrimitive.Real);
graph.SetDef("z", 5);
var result = graph.Solve();
result.AssertNoGenerics();
result.AssertNamed(new StateStruct(new Dictionary <string, TicNode>
{
{ "name", TicNode.CreateTypeVariableNode(StatePrimitive.I32) },
{ "age", TicNode.CreateTypeVariableNode(StatePrimitive.Real) }
}),
"a");
result.AssertNamed(StatePrimitive.I32, "y");
result.AssertNamed(StatePrimitive.Real, "z");
}
public void GetMergedStateOrNull_TwoConcreteStructsWithDifferentFields()
{
var res = SolvingFunctions.GetMergedStateOrNull(
new StateStruct(
new Dictionary <string, TicNode>
{
{ "i", TicNode.CreateTypeVariableNode(StatePrimitive.I32) },
{ "r", TicNode.CreateTypeVariableNode(StatePrimitive.Real) }
}
),
new StateStruct(
new Dictionary <string, TicNode>
{
{ "r", TicNode.CreateTypeVariableNode(StatePrimitive.Real) },
{ "b", TicNode.CreateTypeVariableNode(StatePrimitive.Bool) }
}));
var expected = new StateStruct(
new Dictionary <string, TicNode>
{
{ "i", TicNode.CreateTypeVariableNode(StatePrimitive.I32) },
{ "r", TicNode.CreateTypeVariableNode(StatePrimitive.Real) },
{ "b", TicNode.CreateTypeVariableNode(StatePrimitive.Bool) }
});
Assert.AreEqual(res, expected);
}
public void FunCallWithStruct_StructTypeSolved()
{
// f( input:{field:int} ):bool
//
// 1 2
// x = @(field = 1)
// 4 3
// y = f(x)
TraceLog.IsEnabled = true;
var graph = new GraphBuilder();
graph.SetIntConst(2, StatePrimitive.U8, StatePrimitive.Real, StatePrimitive.Real);
graph.SetStructInit(new[] { "field" }, new[] { 2 }, 1);
graph.SetDef("x", 1);
graph.SetVar("x", 3);
graph.SetCall(new ITicNodeState[]
{
new StateStruct("field", TicNode.CreateTypeVariableNode(StatePrimitive.I32)),
StatePrimitive.Bool
}, new[] { 3, 4 });
graph.SetDef("y", 4);
var result = graph.Solve();
result.AssertNoGenerics();
result.AssertNamed(StatePrimitive.Bool, "y");
var xStruct = result.GetVariableNode("x").State as StateStruct;
var field = xStruct.GetFieldOrNull("field").State as StatePrimitive;
Assert.AreEqual(StatePrimitive.I32, field);
}
public void GetMergedStateOrNull_TwoSameConcreteStructs()
{
var res = SolvingFunctions.GetMergedStateOrNull(
new StateStruct("a", TicNode.CreateTypeVariableNode(StatePrimitive.I32)),
new StateStruct("a", TicNode.CreateTypeVariableNode(StatePrimitive.I32)));
Assert.AreEqual(res, new StateStruct("a", TicNode.CreateTypeVariableNode(StatePrimitive.I32)));
}
public void GetLastCommonAncestorOrNull_ConcreteAndNotConcreteType_ReturnsNull()
{
var funA = StateFun.Of(CreateConstrainsNode(), TicNode.CreateTypeVariableNode(StatePrimitive.I32));
var funB = StateFun.Of(StatePrimitive.U16, StatePrimitive.U64);
Assert.IsNull(funA.GetLastCommonAncestorOrNull(funB));
Assert.IsNull(funB.GetLastCommonAncestorOrNull(funA));
}
public static StateFun Of(ITypeState[] argTypes, ITypeState retType)
{
var argNodes = new TicNode[argTypes.Length];
for (int i = 0; i < argTypes.Length; i++)
{
argNodes[i] = TicNode.CreateTypeVariableNode(argTypes[i]);
}
return(new StateFun(
argNodes: argNodes,
retNode: TicNode.CreateTypeVariableNode(retType)));
}
public void FunDefCallTest_returnIsStrict()
{
// 1 0
//call(f,x):int = f(x)
var graph = new GraphBuilder();
graph.SetVar("x", 0);
graph.SetCall("f", 0, 1);
graph.SetVarType("return", StatePrimitive.I32);
graph.SetDef("return", 1);
var result = graph.Solve();
var t = result.AssertAndGetSingleGeneric(null, null);
result.AssertAreGenerics(t, "x");
result.AssertNamed(StateFun.Of(t, TicNode.CreateTypeVariableNode(StatePrimitive.I32)), "f");
result.AssertNamed(StatePrimitive.I32, "return");
}
public static StateStruct Of(IEnumerable <KeyValuePair <string, ITicNodeState> > fields)
{
var nodeFields = new Dictionary <string, TicNode>();
foreach (var field in fields)
{
TicNode node = null;
if (field.Value is ITypeState at)
{
node = TicNode.CreateTypeVariableNode(at);
}
else if (field.Value is StateRefTo aRef)
{
node = aRef.Node;
}
else
{
throw new InvalidOperationException();
}
nodeFields.Add(field.Key, node);
}
return(new StateStruct(nodeFields));
}
public static StateFun Of(ITicNodeState[] argTypes, ITicNodeState returnType)
{
TicNode[] argNodes = new TicNode[argTypes.Length];
TicNode retNode = null;
if (returnType is ITypeState rt)
{
retNode = TicNode.CreateTypeVariableNode(rt);
}
else if (returnType is StateRefTo retRef)
{
retNode = retRef.Node;
}
else
{
throw new InvalidOperationException();
}
for (int i = 0; i < argTypes.Length; i++)
{
if (argTypes[i] is ITypeState at)
{
argNodes[i] = TicNode.CreateTypeVariableNode(at);
}
else if (argTypes[i] is StateRefTo aRef)
{
argNodes[i] = aRef.Node;
}
else
{
throw new InvalidOperationException();
}
}
return(new StateFun(argNodes, retNode));
}
public static StateArray Of(ITypeState type) => new StateArray(TicNode.CreateTypeVariableNode(type));
private TicNode CreateConstrainsNode()
=> TicNode.CreateTypeVariableNode("", new ConstrainsState());