private static IExpressionNode BuildExpression(
ISyntaxNode node,
IFunctionDictionary functions,
VariableDictionary variables,
TypeInferenceResults typeInferenceResults,
TicTypesConverter typesConverter) =>
node.Accept(new ExpressionBuilderVisitor(functions, variables, typeInferenceResults, typesConverter));
public static GenericUserFunction Create(
TypeInferenceResults typeInferenceResults,
UserFunctionDefinitionSyntaxNode syntaxNode,
IFunctionDictionary dictionary)
{
var ticGenerics = typeInferenceResults.Generics;
var langConstrains = new GenericConstrains[ticGenerics.Length];
for (int i = 0; i < ticGenerics.Length; i++)
{
var ticConstrains = ticGenerics[i];
langConstrains[i] = GenericConstrains.FromTicConstrains(ticConstrains);
}
var ticFunName = syntaxNode.Id + "'" + syntaxNode.Args.Count;
var ticSignature = (StateFun)typeInferenceResults.GetVariableType(ticFunName);
var signatureConverter = TicTypesConverter.GenericSignatureConverter(ticGenerics);
var argTypes = new FunnyType[ticSignature.ArgNodes.Length];
for (var i = 0; i < ticSignature.ArgNodes.Length; i++)
{
argTypes[i] = signatureConverter.Convert(ticSignature.ArgNodes[i].State);
}
var retType = signatureConverter.Convert(ticSignature.ReturnType);
#if DEBUG
TraceLog.WriteLine($"CREATE GENERIC FUN {syntaxNode.Id}({string.Join(",",argTypes)}):{retType}");
TraceLog.WriteLine($" ...where {string.Join(", ", langConstrains)}");
#endif
var function = new GenericUserFunction(typeInferenceResults, syntaxNode, dictionary, langConstrains, retType, argTypes);
return(function);
}
private ExpressionBuilderVisitor(
IFunctionDictionary functions,
VariableDictionary variables,
TypeInferenceResults typeInferenceResults,
TicTypesConverter typesConverter)
{
_functions = functions;
_variables = variables;
_typeInferenceResults = typeInferenceResults;
_typesConverter = typesConverter;
}
public static void CreateSomeConcrete(GenericUserFunction function)
{
var varType = new FunnyType[function._constrainsMap.Length];
for (var i = 0; i < function._constrainsMap.Length; i++)
{
var anc = function._constrainsMap[i].Ancestor ?? StatePrimitive.Any;
var concrete = TicTypesConverter.ToConcrete(anc.Name);
varType[i] = concrete;
}
function.CreateConcrete(varType);
}
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 static ConcreteUserFunction BuildConcrete(
this UserFunctionDefinitionSyntaxNode functionSyntax,
FunnyType[] argTypes,
FunnyType returnType,
IFunctionDictionary functionsDictionary,
TypeInferenceResults results,
TicTypesConverter converter)
{
var vars = new VariableDictionary(functionSyntax.Args.Count);
for (int i = 0; i < functionSyntax.Args.Count; i++)
{
var variableSource = RuntimeBuilderHelper.CreateVariableSourceForArgument(
argSyntax: functionSyntax.Args[i],
actualType: argTypes[i]);
if (!vars.TryAdd(variableSource))
{
throw ErrorFactory.FunctionArgumentDuplicates(functionSyntax, functionSyntax.Args[i]);
}
}
var bodyExpression = ExpressionBuilderVisitor.BuildExpression(
node: functionSyntax.Body,
functions: functionsDictionary,
outputType: returnType,
variables: vars,
typeInferenceResults: results,
typesConverter: converter);
vars.ThrowIfSomeVariablesNotExistsInTheList(
functionSyntax.Args.Select(a => a.Id));
var function = ConcreteUserFunction.Create(
isRecursive: functionSyntax.IsRecursive,
name: functionSyntax.Id,
variables: vars.GetAllSources().ToArray(),
isReturnTypeStrictlyTyped: functionSyntax.ReturnType != FunnyType.Empty,
expression: bodyExpression);
return(function);
}
public override IConcreteFunction CreateConcrete(FunnyType[] concreteTypes)
{
BuiltCount++;
var id = string.Join(",", concreteTypes);
if (_concreteFunctionsCache.TryGetValue(id, out var alreadyExists))
{
return(alreadyExists);
}
//set types to nodes
var converter = TicTypesConverter.ReplaceGenericTypesConverter(_constrainsMap, concreteTypes);
var ticSignature = _typeInferenceResults.GetVariableType(_syntaxNode.Id + "'" + _syntaxNode.Args.Count);
var funType = converter.Convert(ticSignature);
var returnType = funType.FunTypeSpecification.Output;
var argTypes = funType.FunTypeSpecification.Inputs;
// Create a function prototype and put it to cache for recursive cases
// If the function is recursive - function will take recursive prototype from cache
var concretePrototype = new ConcreteUserFunctionPrototype(Name, returnType, argTypes);
_concreteFunctionsCache.Add(id, concretePrototype);
_syntaxNode.ComeOver(
enterVisitor: new ApplyTiResultEnterVisitor(
solving: _typeInferenceResults,
tiToLangTypeConverter: converter),
exitVisitor: new ApplyTiResultsExitVisitor());
var function = _syntaxNode.BuildConcrete(
argTypes: argTypes,
returnType: returnType,
functionsDictionary: _dictionary,
results: _typeInferenceResults,
converter: converter);
concretePrototype.SetActual(function, _syntaxNode.Interval);
return(function);
}
