/// <summary> /// Заменяет x -> begin result := x.Print end; на x -> begin x.Print end в случае если это один оператор и вызов метода /// /// </summary> public static bool TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(function_lambda_definition lambdaDef) { // SSM 12/12/16 - сделал чтобы всегда эта функция возвращала true. // Посмотрю далее на её поведение. Мне кажется, что если мы попали сюда, то мы хотим присвоить процедурному типу, // и в любом случае это надо интерпретировать как процедуру var stl = lambdaDef.proc_body as SyntaxTree.statement_list; if (stl.expr_lambda_body) { // Очищаем от Result := , который мы создали на предыдущем этапе var ass = stl.list[0] as assign; if (ass != null && ass.to is ident && (ass.to as ident).name.ToLower() == "result") { var f = ass.from; if (f is method_call) { var ff = f as method_call; stl.list[0] = new procedure_call(ff, ff.source_context); // заменить result := Print(x) на Print(x) lambdaDef.return_type = null; return(true); } else { return(false); } } } lambdaDef.return_type = null; return(true); // return false; }
public void for_assignment(object lr0, object lr2) { if (lr0 is ident && lr2 is ident && ((ident)lr2).name.Contains("__lambda__")) { string type_name = ""; var_def_statement vds = find_var_statements(((ident)lr0).name); if (vds != null) { type_name = ((named_type_reference)vds.vars_type).names[0].name; } if (type_name != "") { int ii = 0; while (ii < pascalABC_type_declarations.Count && ((type_declaration)pascalABC_type_declarations[ii]).type_name.name != type_name) { ii++; } if (ii < pascalABC_type_declarations.Count) { type_definition td = ((type_declaration)pascalABC_type_declarations[ii]).type_def; function_lambda_definition fld = find_pascalABC_lambda_name(((ident)lr2).name); fld.return_type = ((function_header)td).return_type; for (int k = 0; k < fld.formal_parameters.params_list.Count && k < ((function_header)td).parameters.params_list.Count; k++) { fld.formal_parameters.params_list[k].vars_type = ((function_header)td).parameters.params_list[k].vars_type; } } pascalABC_var_statements.Remove(vds); } } }
public static procedure_definition ConvertLambdaNodeToProcDefNode(function_lambda_definition functionLambdaDef) { procedure_definition procDef = null; if (functionLambdaDef.return_type == null) { procDef = SyntaxTreeNodesConstructor.CreateProcedureDefinitionNode(new method_name(null, null, new ident(functionLambdaDef.lambda_name, functionLambdaDef.source_context), null), functionLambdaDef.formal_parameters, false, false, functionLambdaDef.proc_body, functionLambdaDef.source_context); } else { procDef = SyntaxTreeNodesConstructor.CreateFunctionDefinitionNode(new method_name(null, null, new ident(functionLambdaDef.lambda_name), null), functionLambdaDef.formal_parameters, false, false, functionLambdaDef.proc_body, functionLambdaDef.return_type, functionLambdaDef.source_context); } procDef.proc_header.name.meth_name.source_context = procDef.proc_header.source_context; functionLambdaDef.proc_definition = procDef; return(procDef); }
/// <summary> /// Временный узел, который используется при выведении типов параметров /// </summary> /// <param name="def"></param> /// <param name="visitor"></param> /// <returns></returns> public static typed_expression GetTempFunctionNodeForTypeInference(function_lambda_definition def, syntax_tree_visitor visitor) { var res = new common_namespace_function_node(def.lambda_name, visitor.get_location(def), null, null); if (def.return_type != null) { res.return_value_type = visitor.convert_strong(def.return_type); } else { res.return_value_type = null; } res.parameters.clear(); if (def.formal_parameters != null && def.formal_parameters.params_list.Count != 0) { for (int i = 0; i < def.formal_parameters.params_list.Count; i++) { for (int j = 0; j < def.formal_parameters.params_list[i].idents.idents.Count; j++) { var new_param = new common_parameter(null, parameter_type.value, res, concrete_parameter_type.cpt_none, visitor.get_location(def.formal_parameters.params_list[i].idents.idents[0])); new_param.type = visitor.convert_strong(def.formal_parameters.params_list[i].vars_type); res.parameters.AddElement(new_param); } } } var hhh = new delegated_methods(); hhh.proper_methods.AddElement(new common_namespace_function_call(res, visitor.get_location(def))); return(new typed_expression(hhh, visitor.get_location(def))); }
public CapturedVariablesTreeNodeLambdaScope(CapturedVariablesTreeNode parentNode, function_lambda_definition lambdaDef, int scopeNum, syntax_tree_node correspondingSyntaxTreeNode) : base(parentNode, scopeNum, correspondingSyntaxTreeNode) { LambdaDefinition = lambdaDef; CapturedVarsSymbolInfo = new List <SymbolInfo>(); ScopeIndexOfClassWhereLambdaWillBeAddedAsMethod = null; }
public override void visit(function_lambda_definition fld) { ProcessNode(fld.proc_body); if (fld.unpacked_params == null) { return; } fld.formal_parameters = new formal_parameters(); fld.formal_parameters.source_context = fld.source_context; // Пусть параметр имеет вид \(x,y) // Тогда в начало тела лямбды надо добавить var (x,y) = #fpl1; //var idl = new ident_list(fld.unpacked_params.Select(p => p.id).ToList(),fld.source_context); // //var ass = new assign_var_tuple(idl, main_param_id, fld.source_context); List <statement> res = new List <statement>(); foreach (var param in fld.unpacked_params) { if (param is unpacked_list_of_ident_or_list unpacked_param) { var lam_inft = new lambda_inferred_type(new lambda_any_type_node()); var param_id = CreateIdent(fld.source_context); var idlist = new ident_list(param_id, unpacked_param.source_context); var typed_pars = new typed_parameters(idlist, lam_inft, parametr_kind.none, null, unpacked_param.source_context); fld.formal_parameters.Add(typed_pars, unpacked_param.source_context); fld.ident_list.Add(param_id); fld.parameters.Add(param_id); CreateUnpackedListOfAssignments(unpacked_param, res, param_id, unpacked_param.source_context); } else if (param is ident id) { var lam_inft = new lambda_inferred_type(new lambda_any_type_node()); var idlist = new ident_list(id, id.source_context); var typed_pars = new typed_parameters(idlist, lam_inft); fld.formal_parameters.Add(typed_pars, fld.source_context); fld.ident_list.Add(id); fld.parameters.Add(id); } } var stl = fld.proc_body as statement_list; res.Reverse(); foreach (var st in res) { var ass = st as assign_var_tuple; ass.idents.source_context = new SourceContext(ass.idents[0].source_context, ass.idents[ass.idents.Count - 1].source_context); ass.expr.source_context = ass.idents.source_context; stl.Insert(0, st); // возможно, в обратном порядке } //stl.Insert(0, ass); fld.unpacked_params = null; // на рассахаренном уровне это поле нулевое! }
public procedure_definition lambda(function_lambda_definition _function_lambda_definition) { procedure_definition _func_def = new procedure_definition(); method_name _method_name1 = new method_name(null, null, new ident(_function_lambda_definition.lambda_name), null); //parsertools.create_source_context(_method_name1, _method_name1.meth_name, _method_name1.meth_name); function_header _function_header1 = new function_header(); object rt1 = new object(); _function_header1.name = _method_name1; if (_function_header1.name.meth_name is template_type_name) { _function_header1.template_args = (_function_header1.name.meth_name as template_type_name).template_args; ident id = new ident(_function_header1.name.meth_name.name); //parsertools.create_source_context(id, _function_header1.name.meth_name, _function_header1.name.meth_name); _function_header1.name.meth_name = id; } formal_parameters fps = new PascalABCCompiler.SyntaxTree.formal_parameters(); _function_header1.parameters = _function_lambda_definition.formal_parameters;//fps; /*SyntaxTree.named_type_reference _named_type_reference = new SyntaxTree.named_type_reference(); * SyntaxTree.ident idtype = new SyntaxTree.ident("object"); * _named_type_reference.source_context = idtype.source_context; * _named_type_reference.names.Add(idtype); * rt1 = _named_type_reference; * _function_header1.return_type = (SyntaxTree.type_definition)_named_type_reference;*/ _function_header1.return_type = _function_lambda_definition.return_type; _function_header1.of_object = false; _function_header1.class_keyword = false; token_info _token_info = new token_info("function"); //_token_info.source_context = parsertools.GetTokenSourceContext(); //parsertools.create_source_context(_function_header1, _token_info, _token_info); block _block1 = new block(null, null); statement_list sl1 = new statement_list(); sl1.subnodes.Add(_function_lambda_definition.proc_body); _block1.program_code = sl1; _func_def.proc_header = _function_header1; _func_def.proc_body = (proc_block)_block1; if (_function_lambda_definition.defs != null) { if (((block)_func_def.proc_body).defs == null) { ((block)_func_def.proc_body).defs = new declarations(); } for (int l = 0; l < _function_lambda_definition.defs.Count; l++) { ((block)_func_def.proc_body).defs.defs.Add(_function_lambda_definition.defs[l] as procedure_definition); } } _function_lambda_definition.proc_definition = _func_def; //parsertools.create_source_context(_func_def, _function_header1, _function_header1); return(_func_def); }
public override void visit(function_lambda_definition ld) { if (ld.DescendantNodes().OfType <yield_node>().Count() > 0) { throw new SyntaxVisitorError("LAMBDA_EXPRESSIONS_CANNOT_CONTAIN_YIELD", ld.source_context); } //base.visit(ld); // SSM 15/07/16 - незачем обходить внутренности лямбды - мы и так ищем внутри них yield - этого в этом визиторе достаточно }
public override void visit(function_lambda_definition lambdaDefinition) { if (lambdaDefinition.formal_parameters != null && lambdaDefinition.formal_parameters.params_list != null && lambdaDefinition.formal_parameters.params_list.Count != 0) { var varDefsList = new List <statement>(); for (var i = 0; i < lambdaDefinition.formal_parameters.params_list.Count; i++) { var varType = lambdaDefinition.formal_parameters.params_list[i].vars_type is lambda_inferred_type? LambdaHelper.ConvertSemanticTypeToSyntaxType((type_node)((lambda_inferred_type)lambdaDefinition.formal_parameters.params_list[i].vars_type).real_type) : //new semantic_type_node(((lambda_inferred_type)lambdaDefinition.formal_parameters.params_list[i].vars_type).real_type): // SSM 29/12/18 поменял - пробую - не получилось lambdaDefinition.formal_parameters.params_list[i].vars_type; for (var j = 0; j < lambdaDefinition.formal_parameters.params_list[i].idents.idents.Count; j++) { var varName = "<>" + lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name; SourceContext sc = lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].source_context; var vds = new var_def_statement(new ident(lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name, sc), varType, sc); vds.inital_value = new ident(varName, sc); lambdaDefinition.formal_parameters.params_list[i].idents.idents[j].name = varName; varDefsList.Add(new var_statement(vds, sc)); } } ((statement_list)lambdaDefinition.proc_body).subnodes.InsertRange(0, varDefsList); } var procDecl = LambdaHelper.ConvertLambdaNodeToProcDefNode(lambdaDefinition); _visitor.body_exists = true; _visitor.hard_node_test_and_visit(procDecl.proc_header); var newTreeNode = new CapturedVariablesTreeNodeLambdaScope(_currentTreeNode, lambdaDefinition, _visitor.context.func_stack.top().scope.ScopeNum, lambdaDefinition); _currentTreeNode.LambdasDefinedInScope.Add(newTreeNode); _currentLambdaScopeNodeStack.Push(newTreeNode); if (_currentTreeNode != null) { _currentTreeNode.ChildNodes.Add(newTreeNode); } _currentTreeNode = newTreeNode; _scopesCapturedVarsNodesDictionary.Add(_currentTreeNode.ScopeIndex, _currentTreeNode); VisitProcParameters(procDecl.proc_header.parameters); ProcessNode(procDecl.proc_body); _visitor.context.leave_block(); _visitor.context.remove_lambda_function(procDecl.proc_header.name.meth_name.name, false); _currentTreeNode = _currentTreeNode.ParentNode; _currentLambdaScopeNodeStack.Pop(); LambdaHelper.RemoveLambdaInfoFromCompilationContext(_visitor.context, lambdaDefinition); }
public override void visit(function_lambda_definition fld) { countNestedLambdas += 1; if (countNestedLambdas > 10) { throw new SyntaxVisitors.SyntaxVisitorError("NESTED_LAMBDAS_MAXIMUM_10", fld.source_context); } ProcessNode(fld.proc_body); countNestedLambdas -= 1; }
public override void visit(function_lambda_definition fld) { BlockNamesStack.Add(new Dictionary <string, string>()); var last = BlockNamesStack.Count - 1; for (var i = 0; i < fld.parameters.expressions.Count; i++) { var qname = (fld.parameters.expressions[i] as ident).name.ToLower(); BlockNamesStack[last][qname] = "-fl"; // -fl - формальный параметр лямбды - это стоп в поиске в GetNewVariableName } base.visit(fld); }
public override void visit(function_lambda_definition fd) { PushNamespace(fd); if (fd.formal_parameters != null) { var allnames = fd.formal_parameters.params_list.SelectMany(tp => tp.idents.idents); foreach (var name in allnames) { AddNameNewName(name, null); // null означает, что переименовывать не надо } } base.visit(fd); PopNamespace(); }
public override void visit(function_lambda_definition fld) { InLambda = true; // Исключить все параметры из idents foreach (var fid in fld.ident_list.idents) { var ind = idents.FindIndex(x => string.Compare(x.name, fid.name, true) == 0); if (ind != -1) { idents.RemoveAt(ind); } } ProcessNode(fld.proc_body); }
/// <summary> /// Фиктивный блок, представляющий лямбда-выражение. Используется для обхода с целью получения списка захватываемых переменных /// </summary> /// <param name="lambdaDef"></param> /// <returns></returns> public static block CreateFictiveBlockForLambda(function_lambda_definition lambdaDef) { statement_list stmtList = new statement_list(); if (lambdaDef.formal_parameters != null) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { stmtList.subnodes.Add(SyntaxTreeNodesConstructor.CreateVarStatementNode(lambdaDef.formal_parameters.params_list[i].idents, lambdaDef.formal_parameters.params_list[i].vars_type, null)); } } if (lambdaDef.return_type != null) { stmtList.subnodes.Add(SyntaxTreeNodesConstructor.CreateVarStatementNode("result", lambdaDef.return_type, null)); // переделать, не сработает, если тип возвращаемого значения не указан } stmtList.subnodes.AddRange((lambdaDef.proc_body as statement_list).subnodes); block resBlock = new block(); resBlock.program_code = stmtList; return(resBlock); }
/// <summary> /// Заменяет x -> begin result := x.Print end; на x -> begin x.Print end в случае если это один оператор и вызов метода /// /// </summary> public static bool TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(function_lambda_definition lambdaDef) { var stl = lambdaDef.proc_body as SyntaxTree.statement_list; if (stl.expr_lambda_body) { // Очищаем от Result := var ass = stl.list[0] as assign; if (ass != null && ass.to is ident && (ass.to as ident).name.ToLower() == "result") { var f = ass.from; if (f is method_call) { var ff = f as method_call; stl.list[0] = new procedure_call(ff, ff.source_context); // заменить result := Print(x) на Print(x) lambdaDef.return_type = null; return(true); } } } return(false); }
public override void visit(function_lambda_definition fd) { }
public override void visit(function_lambda_definition fld) { LambdasCount++; base.visit(fld); }
public override void visit(function_lambda_definition fd) { // не заходить во внутренние лямбды }
public static void RemoveLambdaInfoFromCompilationContext(compilation_context context, function_lambda_definition lambdaDefinition) { if (context.converted_namespace != null && context.converted_namespace.functions != null && context.converted_namespace.functions.Any()) // Если добавилось в глобальные функции, то удаляем оттуда { var lastIndex = context.converted_namespace.functions.Count - 1; if (context.converted_namespace.functions[lastIndex].name == lambdaDefinition.lambda_name) { context.converted_namespace.functions.remove_at(lastIndex); } } //else SSM 27/04/16 - грубое исправление ошибки #147 { // Если добавилась лямбда как метод класса, то удаляем оттуда if (context.converted_type != null && context.converted_type.methods != null && context.converted_type.methods.Any()) { var lastIndex = context.converted_type.methods.Count - 1; if (context.converted_type.methods[lastIndex].name == lambdaDefinition.lambda_name) { context.converted_type.methods.remove_at(lastIndex); } } } }
/// <summary> /// Вывод типа параметров лямбд и типа возвращаемого значения при присваивании лямбды переменной /// </summary> public static void InferTypesFromVarStmt(type_node leftType, function_lambda_definition lambdaDef, syntax_tree_visitor visitor, Operators op = Operators.Undefined) { if (lambdaDef == null) { return; } if (leftType != null) { delegate_internal_interface dii_left = (delegate_internal_interface)leftType.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left == null) { if (leftType != SystemLibrary.SystemLibrary.system_delegate_type) { if (op != Operators.Undefined) { var sil = leftType.find_in_type(name_reflector.get_name(op)); if (sil != null && sil.Count > 0) { foreach (SymbolInfo si in sil) { if (si.sym_info is function_node) { function_node fn = si.sym_info as function_node; if (fn.parameters.Count == 2) { dii_left = (delegate_internal_interface)fn.parameters[1].type.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } if (fn.parameters[1].type.is_generic_parameter) { compiled_type_node ctn = leftType as compiled_type_node; common_type_node ctn2 = leftType as common_type_node; if (ctn != null && ctn.is_generic_type_instance && fn.parameters[0].type.is_generic_type_instance && ctn.original_generic == fn.parameters[0].type.original_generic) { dii_left = (delegate_internal_interface)ctn.generic_params[0].get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } } if (ctn2 != null && ctn2.is_generic_type_instance && ctn2.instance_params.Count > 0 && fn.parameters[0].type.is_generic_type_instance && ctn2.original_generic == fn.parameters[0].type.original_generic) { dii_left = (delegate_internal_interface)ctn2.instance_params[0].get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left != null) { break; } } } } } } } } if (dii_left == null) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } else { return; } } int leftTypeParamsNumber = dii_left.parameters.Count; int lambdaDefParamsCount = 0; if (lambdaDef.formal_parameters != null && lambdaDef.formal_parameters.params_list.Count != 0) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { lambdaDefParamsCount += lambdaDef.formal_parameters.params_list[i].idents.idents.Count; } if (lambdaDefParamsCount != leftTypeParamsNumber) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_PARAMETERS_NUMBER"); } bool flag = true; SyntaxTree.formal_parameters lambdaDefParamsTypes = new formal_parameters(); for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { for (int j = 0; j < lambdaDef.formal_parameters.params_list[i].idents.idents.Count; j++) { var param = new SyntaxTree.typed_parameters(); param.idents = new ident_list(); param.idents.Add(lambdaDef.formal_parameters.params_list[i].idents.idents[j]); param.vars_type = lambdaDef.formal_parameters.params_list[i].vars_type; param.source_context = lambdaDef.formal_parameters.source_context; lambdaDefParamsTypes.Add(param); } } for (int i = 0; i < leftTypeParamsNumber && flag; i++) { if (lambdaDefParamsTypes.params_list[i].vars_type is SyntaxTree.lambda_inferred_type) { if ((lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type is lambda_any_type_node) { var curLeftParType = dii_left.parameters[i].type; lambdaDefParamsTypes.params_list[i].vars_type = new SyntaxTree.lambda_inferred_type(); (lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type = curLeftParType; continue; } } var lambdaPar = visitor.convert_strong(lambdaDefParamsTypes.params_list[i].vars_type); if (!convertion_data_and_alghoritms.eq_type_nodes(dii_left.parameters[i].type, lambdaPar)) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } lambdaDef.formal_parameters = lambdaDefParamsTypes; } if (lambdaDef.return_type != null && lambdaDef.return_type is lambda_inferred_type) { if (dii_left.return_value_type != null) { (lambdaDef.return_type as lambda_inferred_type).real_type = dii_left.return_value_type; } else // SSM 23/07/16 - попытка бороться с var p: Shape->() := a->a.Print() { // lambdaDef.usedkeyword == 1 // function var b = lambdaDef.usedkeyword == 0 && TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(lambdaDef); // пытаться конвертировать только если мы явно не указали, что это функция if (!b) { visitor.AddError(visitor.get_location(lambdaDef), "UNABLE_TO_CONVERT_FUNCTIONAL_TYPE_TO_PROCEDURAL_TYPE"); } } } } else { if (lambdaDef.formal_parameters != null) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { if (lambdaDef.formal_parameters.params_list[i].vars_type is lambda_inferred_type) { visitor.AddError(visitor.get_location(lambdaDef), "IMPOSSIBLE_TO_INFER_TYPES_IN_LAMBDA"); } } } } }
public override void visit(function_lambda_definition fld) { // Нельзя Lowerить содержимое лямбды !!! Баг #1641! }
/// <summary> /// Вывод типа параметров лямбд и типа возвращаемого значения при присваивании лямбды переменной /// </summary> public static void InferTypesFromVarStmt(type_node leftType, function_lambda_definition lambdaDef, syntax_tree_visitor visitor) { if (lambdaDef == null) { return; } if (leftType != null) { delegate_internal_interface dii_left = (delegate_internal_interface)leftType.get_internal_interface(internal_interface_kind.delegate_interface); if (dii_left == null) { if (leftType != SystemLibrary.SystemLibrary.system_delegate_type) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } else { return; } } int leftTypeParamsNumber = dii_left.parameters.Count; int lambdaDefParamsCount = 0; if (lambdaDef.formal_parameters != null && lambdaDef.formal_parameters.params_list.Count != 0) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { lambdaDefParamsCount += lambdaDef.formal_parameters.params_list[i].idents.idents.Count; } if (lambdaDefParamsCount != leftTypeParamsNumber) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_PARAMETERS_NUMBER"); } bool flag = true; SyntaxTree.formal_parameters lambdaDefParamsTypes = new formal_parameters(); for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { for (int j = 0; j < lambdaDef.formal_parameters.params_list[i].idents.idents.Count; j++) { var param = new SyntaxTree.typed_parameters(); param.idents = new ident_list(); param.idents.Add(lambdaDef.formal_parameters.params_list[i].idents.idents[j]); param.vars_type = lambdaDef.formal_parameters.params_list[i].vars_type; param.source_context = lambdaDef.formal_parameters.source_context; lambdaDefParamsTypes.Add(param); } } for (int i = 0; i < leftTypeParamsNumber && flag; i++) { if (lambdaDefParamsTypes.params_list[i].vars_type is SyntaxTree.lambda_inferred_type) { if ((lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type is lambda_any_type_node) { var curLeftParType = dii_left.parameters[i].type; lambdaDefParamsTypes.params_list[i].vars_type = new SyntaxTree.lambda_inferred_type(); (lambdaDefParamsTypes.params_list[i].vars_type as SyntaxTree.lambda_inferred_type).real_type = curLeftParType; continue; } } var lambdaPar = visitor.convert_strong(lambdaDefParamsTypes.params_list[i].vars_type); if (!convertion_data_and_alghoritms.eq_type_nodes(dii_left.parameters[i].type, lambdaPar)) { visitor.AddError(visitor.get_location(lambdaDef), "ILLEGAL_LAMBDA_VARIABLE_TYPE"); } } lambdaDef.formal_parameters = lambdaDefParamsTypes; } if (lambdaDef.return_type != null && lambdaDef.return_type is lambda_inferred_type) { if (dii_left.return_value_type != null) { (lambdaDef.return_type as lambda_inferred_type).real_type = dii_left.return_value_type; } else // SSM 23/07/16 - попытка бороться с var p: Shape->() := a->a.Print() { var b = TryConvertFuncLambdaBodyWithMethodCallToProcLambdaBody(lambdaDef); if (!b) { throw new SimpleSemanticError(visitor.get_location(lambdaDef), "UNABLE_TO_CONVERT_FUNCTIONAL_TYPE_TO_PROCEDURAL_TYPE"); } } } } else { if (lambdaDef.formal_parameters != null) { for (int i = 0; i < lambdaDef.formal_parameters.params_list.Count; i++) { if (lambdaDef.formal_parameters.params_list[i].vars_type is lambda_inferred_type) { visitor.AddError(visitor.get_location(lambdaDef), "IMPOSSIBLE_TO_INFER_TYPES_IN_LAMBDA"); } } } } }
public override void visit(function_lambda_definition node) { prepare_node(node.formal_parameters, "formal_parameters"); prepare_node(node.return_type, "return_type"); }
public virtual void visit(function_lambda_definition _function_lambda_definition) { DefaultVisit(_function_lambda_definition); }
public override void visit(function_lambda_definition _function_lambda_definition) { DefaultVisit(_function_lambda_definition); pre_do_visit(_function_lambda_definition); visit(function_lambda_definition.ident_list); visit(function_lambda_definition.return_type); visit(function_lambda_definition.formal_parameters); visit(function_lambda_definition.proc_body); visit(function_lambda_definition.proc_definition); visit(function_lambda_definition.parameters); for (int i = 0; i < defs.Count; i++) visit(function_lambda_definition.defs[i]); visit(function_lambda_definition.substituting_node); post_do_visit(_function_lambda_definition); }
public virtual void post_do_visit(function_lambda_definition _function_lambda_definition) { }
public override void visit(function_lambda_definition _function_lambda_definition) { executer.visit(_function_lambda_definition); if (_function_lambda_definition.ident_list != null) this.visit((dynamic)_function_lambda_definition.ident_list); if (_function_lambda_definition.return_type != null) this.visit((dynamic)_function_lambda_definition.return_type); if (_function_lambda_definition.formal_parameters != null) this.visit((dynamic)_function_lambda_definition.formal_parameters); if (_function_lambda_definition.proc_body != null) this.visit((dynamic)_function_lambda_definition.proc_body); if (_function_lambda_definition.proc_definition != null) this.visit((dynamic)_function_lambda_definition.proc_definition); if (_function_lambda_definition.parameters != null) this.visit((dynamic)_function_lambda_definition.parameters); if (_function_lambda_definition.defs != null) foreach (dynamic x in _function_lambda_definition.defs) if(x != null) this.visit(x); if (_function_lambda_definition.attributes != null) this.visit((dynamic)_function_lambda_definition.attributes); }
public HasCapturedLambdaParameterInInternalLambdaBody(function_lambda_definition fld) { idents = fld.ident_list.idents; }
public static HasCapturedLambdaParameterInInternalLambdaBody New(function_lambda_definition fld) { return(new HasCapturedLambdaParameterInInternalLambdaBody(fld)); }
public ident func_decl_lambda(object lr0, object lr2) { statement_list _statement_list = (statement_list)lr2; expression_list _expression_list = new expression_list(); ident_list _i_l = new ident_list(); formal_parameters _formal_parameters = new formal_parameters(); if (lr0 != null) { List <object> ar = (List <object>)lr0; for (int i = 0; i < ar.Count; i++) { if (ar[i] is ident) { _i_l.idents.Add((ident)ar[i]); } else { _i_l.idents.Add(((var_def_statement)ar[i]).vars.idents[0]); } } for (int i = 0; i < _i_l.idents.Count; i++) { _expression_list.expressions.Add(_i_l.idents[i]); } for (int i = 0; i < ar.Count; i++) { ident_list _ident_list = new ident_list(); ident id = _i_l.idents[i]; _ident_list.idents.Add(id); string name_param = id.name; typed_parameters _typed_parameters = null; int k = 0; { named_type_reference _named_type_reference = new named_type_reference(); type_definition t_d = new type_definition(); if (ar[i] is ident) { ident idtype = new ident("object"); _named_type_reference.names.Add(idtype); t_d = (type_definition)_named_type_reference; } else { t_d = ((var_def_statement)ar[i]).vars_type; } _typed_parameters = new typed_parameters(_ident_list, t_d, parametr_kind.none, null); //parsertools.create_source_context(_typed_parameters, _ident_list, t_d); } _formal_parameters.params_list.Add(_typed_parameters); } } ////////////////////////// named_type_reference _named_type_reference1 = new named_type_reference(); ident idtype1 = new ident("object"); _named_type_reference1.source_context = idtype1.source_context; _named_type_reference1.names.Add(idtype1); ///////////////////////////// lambda_num++; function_lambda_definition _procedure_definition = new function_lambda_definition(); _procedure_definition.formal_parameters = _formal_parameters; _procedure_definition.return_type = (type_definition)_named_type_reference1; _procedure_definition.ident_list = _i_l; _procedure_definition.proc_body = null; _procedure_definition.parameters = _expression_list; _procedure_definition.lambda_name = "__lambda__" + lambda_num; //new function_lambda_definition(_formal_parameters, (type_definition)_named_type_reference1, _i_l, null, _expression_list, "lambda" + lambda_num); object rt = _i_l; _procedure_definition.proc_body = _statement_list; //////////////////////////////vnutrennie lambda if (_procedure_definition.defs == null) { _procedure_definition.defs = new List <declaration>(); } while (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] != null) { _procedure_definition.defs.Add(lambda((function_lambda_definition)pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1])); pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1); } if (pascalABC_lambda_definitions.Count > 0 && pascalABC_lambda_definitions[pascalABC_lambda_definitions.Count - 1] == null) { pascalABC_lambda_definitions.RemoveAt(pascalABC_lambda_definitions.Count - 1); } pascalABC_lambda_definitions.Add(_procedure_definition); /////////////////////////////////////////////// //parsertools.create_source_context(_procedure_definition, _expression_list, rt); ident _name = new ident(_procedure_definition.lambda_name); if (lr0 != null) { _name.source_context = _i_l.idents[0].source_context; } return(_name); }
public override void visit(function_lambda_definition _function_lambda_definition) { throw new NotImplementedException(); }
public override void visit(function_lambda_definition lambdaDef) { FoundLambda = lambdaDef; throw new LambdaIsFound(); }
public virtual void visit(function_lambda_definition _function_lambda_definition) { }