public override IConcreteFunction CreateConcrete(FunnyType[] concreteTypes)
{
var from = concreteTypes[1];
var to = concreteTypes[0];
if (to == FunnyType.Anything || from == to)
{
return(new ConcreteConverter(o => o, from, to));
}
if (to == FunnyType.Text)
{
return(new ConcreteConverter(o => o.ToString(), from, to));
}
var safeConverter = VarTypeConverter.GetConverterOrNull(from, to);
if (safeConverter != null)
{
return(new ConcreteConverter(safeConverter, from, to));
}
if (to.ArrayTypeSpecification?.FunnyType == FunnyType.UInt8)
{
var serializer = CreateSerializerOrNull(from);
if (serializer != null)
{
return(new ConcreteConverter(serializer, from, to));
}
}
else if (to.ArrayTypeSpecification?.FunnyType == FunnyType.Bool)
{
var serializer = CreateBinarizerOrNull(from);
if (serializer != null)
{
return(new ConcreteConverter(serializer, from, to));
}
}
if (from.ArrayTypeSpecification?.FunnyType == FunnyType.UInt8)
{
var deserializer = CreateDeserializerOrNull(to);
if (deserializer != null)
{
return(new ConcreteConverter(deserializer, from, to));
}
}
else if (from.IsText)
{
var parser = CreateParserOrNull(to);
if (parser != null)
{
return(new ConcreteConverter(parser, from, to));
}
}
throw FunParseException.ErrorStubToDo($"Impossible explicit convertation {from}->{to}");
}
public static IExpressionNode GetConvertedOrOriginOrThrow(IExpressionNode origin, FunnyType to)
{
if (origin.Type == to)
{
return(origin);
}
var converter = VarTypeConverter.GetConverterOrThrow(origin.Type, to, origin.Interval);
return(new CastExpressionNode(origin, to, converter, origin.Interval));
}
public void ConvertPrimitives(object from, object expected, BaseFunnyType typeFrom, BaseFunnyType typeTo)
{
Assert.IsTrue(VarTypeConverter.CanBeConverted(
@from: FunnyType.PrimitiveOf(typeFrom),
to: FunnyType.PrimitiveOf(typeTo)));
var converter = VarTypeConverter.GetConverterOrNull(
FunnyType.PrimitiveOf(typeFrom),
FunnyType.PrimitiveOf(typeTo));
var converted = converter(from);
Assert.AreEqual(converted, expected);
}
public void ConvertFun()
{
var typeFrom = FunnyType.Fun(FunnyType.Bool, FunnyType.Int32);
var typeTo = FunnyType.Fun(FunnyType.Text, FunnyType.UInt8);
Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo));
var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo);
Func <int, bool> funcFrom = (input) => input > 0;
var convertedFunc = coverter(new LambdaToFunWrapper <int, bool>(funcFrom)) as IConcreteFunction;
var result = convertedFunc.Calc(new object[] { ((byte)12) });
Assert.IsInstanceOf <IFunArray>(result, $"Actual result is {result}");
Assert.AreEqual((result as IFunArray).ToText(), "True");
}
public void ConvertIntArrayToRealArray()
{
var intArray = new ImmutableFunArray(new[] { 1, 2, 3, 4 });
var typeFrom = FunnyType.ArrayOf(FunnyType.Int32);
var typeTo = FunnyType.ArrayOf(FunnyType.Real);
Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo));
var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo);
var actual = coverter(intArray) as IFunArray;
Assert.IsNotNull(actual);
Assert.AreEqual(typeTo.ArrayTypeSpecification.FunnyType, actual.ElementType);
CollectionAssert.AreEqual(new double[] { 1, 2, 3, 4 }, actual);
}
private IExpressionNode CreateFunctionCall(IFunCallSyntaxNode node, IConcreteFunction function)
{
var children = node.Args.SelectToArray(ReadNode);
var converted = function.CreateWithConvertionOrThrow(children, node.Interval);
if (converted.Type != node.OutputType)
{
var converter = VarTypeConverter.GetConverterOrThrow(converted.Type, node.OutputType, node.Interval);
return(new CastExpressionNode(converted, node.OutputType, converter, node.Interval));
}
else
{
return(converted);
}
}
public void ConvertStruct()
{
var typeTo = FunnyType.StructOf(("name", FunnyType.Text));
var typeFrom = FunnyType.StructOf(("name", FunnyType.Text), ("age", FunnyType.Int32));
Assert.IsTrue(VarTypeConverter.CanBeConverted(typeFrom, typeTo));
var coverter = VarTypeConverter.GetConverterOrNull(typeFrom, typeTo);
var fromStruct = FunnyStruct.Create(("name", new TextFunArray("vasa")), ("age", 42));
var convertedStruct = coverter(fromStruct) as FunnyStruct;
Assert.IsNotNull(convertedStruct);
var val = convertedStruct.GetValue("name") as TextFunArray;
Assert.AreEqual(val, new TextFunArray("vasa"));
}
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval)
{
var i = 0;
var argNode = children[0];
var toType = ArgTypes[i];
var fromType = argNode.Type;
var castedNode = argNode;
if (fromType != toType)
{
var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval);
castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval);
}
i++;
return(new FunOfSingleArgExpressionNode(this, castedNode, interval));
}
public static IExpressionNode BuildExpression(
ISyntaxNode node,
IFunctionDictionary functions,
FunnyType outputType,
VariableDictionary variables,
TypeInferenceResults typeInferenceResults,
TicTypesConverter typesConverter)
{
var result = node.Accept(
new ExpressionBuilderVisitor(functions, variables, typeInferenceResults, typesConverter));
if (result.Type == outputType)
{
return(result);
}
var converter = VarTypeConverter.GetConverterOrThrow(result.Type, outputType, node.Interval);
return(new CastExpressionNode(result, outputType, converter, node.Interval));
}
public IExpressionNode CreateWithConvertionOrThrow(IList <IExpressionNode> children, Interval interval)
{
var castedChildren = new IExpressionNode[children.Count];
var i = 0;
foreach (var argNode in children)
{
var toType = ArgTypes[i];
var fromType = argNode.Type;
var castedNode = argNode;
if (fromType != toType)
{
var converter = VarTypeConverter.GetConverterOrThrow(fromType, toType, argNode.Interval);
castedNode = new CastExpressionNode(argNode, toType, converter, argNode.Interval);
}
castedChildren[i] = castedNode;
i++;
}
return(new FunOfTwoArgsExpressionNode(this, castedChildren[0], castedChildren[1], interval));
}
