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 override void visit(typed_parameters _typed_parametres)
{
if (_typed_parametres.param_kind != parametr_kind.none)
{
AddPossibleComments(_typed_parametres, true, false);
}
_typed_parametres.idents.visit(this);
_typed_parametres.vars_type.visit(this);
if (_typed_parametres.inital_value != null)
{
_typed_parametres.inital_value.visit(this);
}
}
private formal_parameters get_parameters(List <ICSharpCode.NRefactory.Ast.ParameterDeclarationExpression> prms)
{
formal_parameters fp = new formal_parameters();
foreach (ICSharpCode.NRefactory.Ast.ParameterDeclarationExpression prm in prms)
{
typed_parameters tp = new typed_parameters();
tp.source_context = get_source_context(prm);
tp.idents = new ident_list();
tp.idents.idents.Add(new ident(prm.ParameterName));
tp.vars_type = get_type_reference(prm.TypeReference);
tp.inital_value = get_expression(prm.DefaultValue);
switch (prm.ParamModifier)
{
case ICSharpCode.NRefactory.Ast.ParameterModifiers.Ref: tp.param_kind = parametr_kind.var_parametr; break;
case ICSharpCode.NRefactory.Ast.ParameterModifiers.Params: tp.param_kind = parametr_kind.params_parametr; break;
}
fp.params_list.Add(tp);
}
return(fp);
}
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(typed_parameters _typed_parametres)
{
text = _typed_parametres.param_kind.ToString();
}
public virtual void visit(typed_parameters _typed_parameters)
{
DefaultVisit(_typed_parameters);
}
public virtual void post_do_visit(typed_parameters _typed_parameters)
{
}
public override void visit(typed_parameters _typed_parameters)
{
DefaultVisit(_typed_parameters);
pre_do_visit(_typed_parameters);
visit(typed_parameters.idents);
visit(typed_parameters.vars_type);
visit(typed_parameters.inital_value);
post_do_visit(_typed_parameters);
}
public virtual void visit(typed_parameters _typed_parameters)
{
}
public virtual void visit(typed_parameters _typed_parameters)
{
}
public virtual void visit(typed_parameters _typed_parameters)
{
DefaultVisit(_typed_parameters);
}
public override void visit(typed_parameters _typed_parametres)
{
prepare_node(_typed_parametres.idents, "idents");
prepare_node(_typed_parametres.vars_type, "type");
prepare_node(_typed_parametres.inital_value, "inital_value");
}
/// <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.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;
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 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;
lambdaDefParamsTypes.Add(param);
}
}
for (int i = 0; i < leftTypeParamsNumber && flag; i++)
{
if (lambdaDefParamsTypes.params_list[i].vars_type is lambda_inferred_type)
{
if ((lambdaDefParamsTypes.params_list[i].vars_type as lambda_inferred_type).real_type is lambda_any_type_node)
{
var curLeftParType = dii_left.parameters[i].type;
lambdaDefParamsTypes.params_list[i].vars_type = new lambda_inferred_type();
(lambdaDefParamsTypes.params_list[i].vars_type as 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(typed_parameters _typed_parameters)
{
executer.visit(_typed_parameters);
if (_typed_parameters.idents != null)
this.visit((dynamic)_typed_parameters.idents);
if (_typed_parameters.vars_type != null)
this.visit((dynamic)_typed_parameters.vars_type);
if (_typed_parameters.inital_value != null)
this.visit((dynamic)_typed_parameters.inital_value);
if (_typed_parameters.attributes != null)
this.visit((dynamic)_typed_parameters.attributes);
}
