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); }