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