public void RefState_RefToDifferentNodes_EqualReturnsFalse()
{
var state1 = new StateRefTo(TicNode.CreateNamedNode("a", new ConstrainsState()));
var state2 = new StateRefTo(TicNode.CreateNamedNode("b", new ConstrainsState()));
Assert.IsFalse(state1.Equals(state2));
Assert.AreNotEqual(state1, state2);
}
public void RefState_RefToSameNode_EqualReturnsTrue()
{
var node = TicNode.CreateNamedNode("a", new ConstrainsState());
var state1 = new StateRefTo(node);
var state2 = new StateRefTo(node);
Assert.IsTrue(state1.Equals(state2));
Assert.AreEqual(state1, state2);
}
public bool Visit(FunCallSyntaxNode node)
{
var signature = _dictionary.GetOrNull(node.Id, node.Args.Length);
node.FunctionSignature = signature;
//Apply visitor to child types
for (int i = 0; i < node.Args.Length; i++)
{
if (signature != null)
{
_parentFunctionArgType = signature.ArgTypes[i];
}
node.Args[i].Accept(this);
}
//Setup ids arrays
var ids = new int[node.Args.Length + 1];
for (int i = 0; i < node.Args.Length; i++)
{
ids[i] = node.Args[i].OrderNumber;
}
ids[ids.Length - 1] = node.OrderNumber;
var userFunction = _resultsBuilder.GetUserFunctionSignature(node.Id, node.Args.Length);
if (userFunction != null)
{
//Call user-function if it is being built at the same time as the current expression is being built
//for example: recursive calls, or if function relates to global variables
#if DEBUG
Trace(node, $"Call UF{node.Id}({string.Join(",", ids)})");
#endif
_ticTypeGraph.SetCall(userFunction, ids);
//in the case of generic user function - we dont know generic arg types yet
//we need to remember generic TIC signature to used it at the end of interpritation
_resultsBuilder.RememberRecursiveCall(node.OrderNumber, userFunction);
return(true);
}
if (signature == null)
{
//Functional variable
#if DEBUG
Trace(node, $"Call hi order {node.Id}({string.Join(",", ids)})");
#endif
_ticTypeGraph.SetCall(node.Id, ids);
return(true);
}
//Normal function call
#if DEBUG
Trace(node, $"Call {node.Id}({string.Join(",", ids)})");
#endif
if (signature is PureGenericFunctionBase pure)
{
// Сase of (T,T):T signatures
// This case is most common, so the call is optimized
var genericType = InitializeGenericType(pure.Constrainses[0]);
_resultsBuilder.RememberGenericCallArguments(node.OrderNumber, new[] { genericType });
_ticTypeGraph.SetCall(genericType, ids);
return(true);
}
StateRefTo[] genericTypes;
if (signature is GenericFunctionBase t)
{
// Optimization
// Remember generic arguments to use it again at the built time
genericTypes = InitializeGenericTypes(t.Constrainses);
// save refernces to generic types, for use at 'apply tic results' step
_resultsBuilder.RememberGenericCallArguments(node.OrderNumber, genericTypes);
}
else
{
genericTypes = new StateRefTo[0];
}
var types = new ITicNodeState[signature.ArgTypes.Length + 1];
for (int i = 0; i < signature.ArgTypes.Length; i++)
{
types[i] = signature.ArgTypes[i].ConvertToTiType(genericTypes);
}
types[types.Length - 1] = signature.ReturnType.ConvertToTiType(genericTypes);
_ticTypeGraph.SetCall(types, ids);
return(true);
}
