//Добавляет интерфейс и всех его предков в список реализуемых данным классом.
public static void AddInterface(common_type_node cnode, type_node _interface, location loc)
{
if (original_types_equals(_interface, cnode))
{
throw new TreeConverter.UndefinedNameReference(_interface.name, loc);
}
if (!_interface.IsInterface)
{
throw new TreeConverter.SimpleSemanticError(loc, "{0}_IS_NOT_INTERFACE", _interface.name);
}
if (_interface.ForwardDeclarationOnly)
{
throw new TreeConverter.SimpleSemanticError(loc, "FORWARD_DECLARATION_{0}_AS_IMPLEMENTING_INTERFACE", _interface.name);
}
if (!cnode.ImplementingInterfaces.Contains(_interface))
{
cnode.ImplementingInterfaces.Add(_interface);
foreach (type_node tn in _interface.ImplementingInterfaces)
{
if (!cnode.ImplementingInterfaces.Contains(tn))
{
cnode.ImplementingInterfaces.Add(tn);
}
}
}
}
public SymbolInfo(common_type_node value)
{
//_name_information_type=name_information_type.nit_common_type;
_sym_info = value;
_access_level = access_level.al_public;
_symbol_kind = symbol_kind.sk_none;
}
private void VisitCommonType(common_type_node ctn)
{
foreach (common_method_node cmn in ctn.methods)
{
VisitMethod(cmn);
}
}
public class_constant_definition(string name, location loc, common_type_node comprehensive_type, SemanticTree.field_access_level field_access_level)
:
base(name, loc)
{
_comprehensive_type = comprehensive_type;
_fal = field_access_level;
}
public List <type_node> GetParamsList(common_type_node template_instance)
{
/*string key = instance_name;
* int num = 0;
* if (instance_name[instance_name.Length - 1] != '>')
* {
* int i = instance_name.Length - 1;
* while (instance_name[i] != '$')
* {
* i--;
* }
* string snum = instance_name.Substring(i + 1);
* num = Convert.ToInt32(snum);
* key = instance_name.Substring(0, i);
* }
* List<List<type_node>> founded = _instances[key];
* return founded[num];*/
List <type_node> i_params;
if (_instance_params.TryGetValue(template_instance, out i_params))
{
return(i_params);
}
else
{
return(null);
}
}
public common_property_node(string name, common_type_node comprehensive_type, location loc,
SemanticTree.field_access_level field_access_level, SemanticTree.polymorphic_state polymorphic_state)
{
_name = name;
_comprehensive_type = comprehensive_type;
_loc = loc;
_field_access_level = field_access_level;
_polymorphic_state = polymorphic_state;
}
public class_field(string name, type_node type, common_type_node cont_class,
polymorphic_state polymorphic_state, field_access_level field_access_level,
location loc) :
base(name, type)
{
_cont_class = cont_class;
_polymorphic_state = polymorphic_state;
_field_access_level = field_access_level;
_loc = loc;
}
private void SaveType(common_type_node ctn)
{
if (!string.IsNullOrEmpty(ctn.documentation))
{
if (!ctn.documentation.Trim(' ', '\t').StartsWith("<summary>"))
{
xtw.WriteStartElement("member");
xtw.WriteStartAttribute("name");
if (is_assembly)
{
xtw.WriteString("T:" + get_name(ctn));
}
else
{
xtw.WriteString("T:" + ctn.name);
}
xtw.WriteEndAttribute();
xtw.WriteStartElement("summary");
xtw.WriteString(ctn.documentation);
xtw.WriteEndElement();
xtw.WriteEndElement();
}
else
{
string doc = string.Concat("<member name=\"" + "T:" + (is_assembly?get_name(ctn):ctn.name) + "\">", ctn.documentation, "</member>");
StringReader sr = new StringReader(doc);
XmlReader xr = XmlTextReader.Create(sr);
xr.Read();
xtw.WriteNode(xr.ReadSubtree(), false);
sr.Close();
xr.Close();
}
}
foreach (common_method_node cmn in ctn.methods)
{
SaveMethod(cmn);
}
foreach (common_property_node cmn in ctn.properties)
{
SaveProperty(cmn);
}
foreach (common_event ce in ctn.events)
{
SaveEvent(ce);
}
foreach (class_field cmn in ctn.fields)
{
SaveField(cmn);
}
foreach (class_constant_definition cmn in ctn.const_defs)
{
SaveClassConstant(cmn);
}
}
private void CollectInfoFields(common_type_node ctn)
{
if (!ctn.comprehensive_namespace.from_pcu)
{
foreach (class_field fld in ctn.fields)
{
FldInfo fi = helper.GetField(fld);
// if (fi.num_use == 0 && !ctn.name.Contains("$") && fld.field_access_level == SemanticTree.field_access_level.fal_private) warns.Add(new UnusedField(fld.name, fld.loc));
}
}
}
public common_event(string name, type_node del_type, common_type_node cont_type, common_method_node add_method, common_method_node remove_method, common_method_node raise_method,
field_access_level fal, polymorphic_state ps, location loc)
{
this._name = name;
this.del_type = del_type;
this._add_method = add_method;
this._remove_method = remove_method;
this._raise_method = raise_method;
this._field_access_level = fal;
this._polymorphic_state = ps;
this._cont_type = cont_type;
this._loc = loc;
}
public common_property_node(string name, common_type_node comprehensive_type, type_node property_type,
function_node get_function, function_node set_function, location loc,
field_access_level field_access_level, polymorphic_state polymorphic_state)
{
_name = name;
_comprehensive_type = comprehensive_type;
_property_type = property_type;
_get_function = get_function;
_set_function = set_function;
_loc = loc;
_field_access_level = field_access_level;
_polymorphic_state = polymorphic_state;
}
private void VisitCommonTypeHeader(common_type_node ctn)
{
if (ctn.base_type != null && ctn.base_type is common_type_node)
{
VisitCommonTypeHeader(ctn.base_type as common_type_node);
}
current_type = ctn;
foreach (class_field fld in ctn.fields)
{
helper.AddField(fld);
CheckType(fld.type, fld.inital_value, fld.loc);
}
current_type = null;
}
private string get_array_name(common_type_node ctn)
{
StringBuilder sb = new StringBuilder();
sb.Append("@array");
bounded_array_interface bai = ctn.get_internal_interface(internal_interface_kind.bounded_array_interface) as bounded_array_interface;
sb.Append('[');
sb.Append(get_constant(bai.ordinal_type_interface.lower_value));
sb.Append("..");
sb.Append(get_constant(bai.ordinal_type_interface.upper_value));
sb.Append(']');
sb.Append("[" + get_name(ctn.element_type) + "]");
return(sb.ToString());
}
private void make_object_operator(common_type_node ctn, SemanticTree.basic_function_type bas_ft,
string name, type_node ret_type, SemanticTree.parameter_type first_parameter_type)
{
parameterArrayList pars = new parameterArrayList();
basic_function_node bfn = new basic_function_node(bas_ft, pars, ret_type);
bfn.is_overload = true;
basic_parameter to = new basic_parameter(compiler_string_consts.left_param_name, ctn,
first_parameter_type, bfn);
basic_parameter from = new basic_parameter(compiler_string_consts.right_param_name, ctn,
SemanticTree.parameter_type.value, bfn);
pars.Add(to);
pars.Add(from);
ctn.Scope.AddSymbol(name, new SymbolInfo(bfn));
}
private string get_dyn_array_name(common_type_node ctn)
{
type_node tn = ctn.element_type;
int i = 1;
while (tn.type_special_kind == SemanticTree.type_special_kind.array_kind)
{
i++;
tn = tn.element_type;
}
string s = get_name(tn);
for (int j = 0; j < i; j++)
{
s += "[]";
}
return(s);
}
public static bool TypeDependedFromTemplate(type_node tn)
{
common_type_node ctn = tn as common_type_node;
if (ctn == null)
{
return(false);
}
if (ctn.original_template != null)
{
return(true);
}
switch (tn.type_special_kind)
{
case type_special_kind.array_kind:
case type_special_kind.set_type:
//case type_special_kind.typed_file:
return(TypeDependedFromTemplate(tn.element_type));
}
return(false);
}
private string get_delegate_name(common_type_node ctn)
{
common_method_node cmn = ctn.find_in_type(compiler_string_consts.invoke_method_name).sym_info as common_method_node;
StringBuilder sb = new StringBuilder();
if (cmn.return_value_type != null)
{
sb.Append("@function");
}
else
{
sb.Append("@procedure");
}
if (cmn.parameters.Count > 0)
{
sb.Append('(');
for (int i = 0; i < cmn.parameters.Count; i++)
{
sb.Append(get_name(cmn.parameters[i].type));
if (cmn.parameters[i].parameter_type == SemanticTree.parameter_type.var)
{
sb.Append('@');
}
if (i < cmn.parameters.Count - 1)
{
sb.Append(',');
}
}
sb.Append(')');
}
if (cmn.return_value_type != null)
{
sb.Append(":" + get_name(cmn.return_value_type));
}
return(sb.ToString());
}
private string get_binary_file_name(common_type_node ctn)
{
return("@file");
}
private string get_typed_file_name(common_type_node ctn)
{
return("@fileof[" + get_name(ctn.element_type) + "]");
}
public void init_reference_type(common_type_node ctn)
{
make_assign_operator(ctn);
make_equivalence_operator(ctn);
make_not_equivalence_operator(ctn);
}
public void init_reference_type(common_type_node ctn)
{
make_assign_operator(ctn);
make_equivalence_operator(ctn);
make_not_equivalence_operator(ctn);
}
private void make_not_equivalence_operator(common_type_node ctn)
{
make_object_operator(ctn, SemanticTree.basic_function_type.objnoteq, compiler_string_consts.noteq_name, _bool_type);
}
/// <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");
}
}
}
}
}
private string get_set_type_name(common_type_node ctn)
{
return("@set[" + get_name(ctn.element_type) + "]");
}
public common_static_method_call(common_method_node static_method, location loc) :
base(static_method, loc)
{
//_method = static_method;
_common_type = static_method.cont_type;
}
private void make_object_operator(common_type_node ctn, SemanticTree.basic_function_type bas_ft, string name,
type_node ret_type)
{
make_object_operator(ctn, bas_ft, name, ret_type, SemanticTree.parameter_type.value);
}
private string get_diap_name(common_type_node ctn)
{
return("@diap[" + get_constant(ctn.low_bound) + ".." + get_constant(ctn.upper_bound) + "]");
}
private void make_not_equivalence_operator(common_type_node ctn)
{
make_object_operator(ctn,SemanticTree.basic_function_type.objnoteq,compiler_string_consts.noteq_name,_bool_type);
}
private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,
string name,type_node ret_type,SemanticTree.parameter_type first_parameter_type)
{
parameterArrayList pars=new parameterArrayList();
basic_function_node bfn=new basic_function_node(bas_ft,pars,ret_type);
bfn.is_overload=true;
basic_parameter to=new basic_parameter(compiler_string_consts.left_param_name,ctn,
first_parameter_type,bfn);
basic_parameter from=new basic_parameter(compiler_string_consts.right_param_name,ctn,
SemanticTree.parameter_type.value,bfn);
pars.Add(to);
pars.Add(from);
ctn.Scope.AddSymbol(name,new SymbolInfo(bfn));
}
private void make_assign_operator(common_type_node ctn)
{
make_object_operator(ctn, SemanticTree.basic_function_type.objassign, compiler_string_consts.assign_name,
ctn, SemanticTree.parameter_type.var);
}
/// <summary>
/// Автовыведение типов в yield'ax.
/// </summary>
private void ProcessAssigntToAutoType(addressed_expression to, ref expression_node from)
{
var sequence = to.type as compiled_generic_instance_type_node;
// SSM 26.06.16 - правка в связи с автовыведением типов в yieldах
if (to.type is auto_type)
{
try_convert_typed_expression_to_function_call(ref from);
if (to is class_field_reference)
{
var cfr = to as class_field_reference;
if (from is typed_expression) // SSM 22.12.18 syntax_tree_visitor.cs 16066 - взял оттуда
{
base_function_call bfc = ((from as typed_expression).type as delegated_methods).proper_methods[0];
/*if (bfc.function.is_generic_function && _var_def_statement.vars_type == null)
* {
* AddError(inital_value.location, "CAN_NOT_DEDUCE_TYPE_{0}", null);
* }
* foreach (parameter p in bfc.simple_function_node.parameters)
* {
* if (p.type.is_generic_parameter)
* AddError(inital_value.location, "USE_ANONYMOUS_FUNCTION_TYPE_WITH_GENERICS");
* } */
common_type_node del =
convertion_data_and_alghoritms.type_constructor.create_delegate(context.get_delegate_type_name(), bfc.simple_function_node.return_value_type, bfc.simple_function_node.parameters, context.converted_namespace, null);
context.converted_namespace.types.AddElement(del); //- сомневаюсь - контекст уже поменялся!
//tn = del;
from = convertion_data_and_alghoritms.explicit_convert_type(from, del);
from.type = del;
}
cfr.field.type = from.type;
cfr.type = from.type; // Это неверно работает когда yieldится процедура #1439
// SSM 1.11.18 попытка правки возвращения процедуры в yield
//if (from.type.semantic_node_type == semantic_node_type.delegated_method)
//cfr.type.semantic_node_type = semantic_node_type.delegated_method;
cfr.field.inital_value = context.GetInitalValueForVariable(cfr.field, cfr.field.inital_value);
}
else if (to is local_block_variable_reference)
{
var lvr = to as local_block_variable_reference;
lvr.var.type = from.type;
lvr.type = from.type;
lvr.var.inital_value = context.GetInitalValueForVariable(lvr.var, lvr.var.inital_value);
}
else
{
AddError(to.location, "Не могу вывести тип при наличии yield: " + to.type.full_name);
}
//to.type = from.type; // и без всякого real_type!
}
else if (sequence?.instance_params[0] is ienumerable_auto_type)
{
type_node elem_type = null;
try_convert_typed_expression_to_function_call(ref from);
bool bb; // здесь bb не нужно. Оно нужно в foreach
var b = FindIEnumerableElementType(from.type, ref elem_type, out bb);
if (!b)
{
AddError(from.location, "CAN_NOT_EXECUTE_FOREACH_BY_EXPR_OF_TYPE_{0}", from.type.full_name);
}
var IEnumType = new template_type_reference(new named_type_reference("System.Collections.Generic.IEnumerable"),
new template_param_list(new semantic_type_node(elem_type)));
if (to is class_field_reference)
{
var cfr = to as class_field_reference;
cfr.field.type = convert_strong(IEnumType);
cfr.type = cfr.field.type;
}
else if (to is local_block_variable_reference)
{
var lvr = to as local_block_variable_reference;
lvr.var.type = convert_strong(IEnumType); // замена типа у описания переменной
lvr.type = lvr.var.type; // замена типа у переменной
}
}
}
private void make_object_operator(common_type_node ctn,SemanticTree.basic_function_type bas_ft,string name,
type_node ret_type)
{
make_object_operator(ctn,bas_ft,name,ret_type,SemanticTree.parameter_type.value);
}
private void make_assign_operator(common_type_node ctn)
{
make_object_operator(ctn,SemanticTree.basic_function_type.objassign,compiler_string_consts.assign_name,
ctn,SemanticTree.parameter_type.var);
}
/*
* public static_class_field_reference(class_field static_field,common_type_node type,location loc) :
* base(static_field.type,loc)
* {
* _field=static_field;
* _type=type;
* }
*/
public static_class_field_reference(class_field static_field, location loc) :
base(static_field.type, loc)
{
_field = static_field;
_type = static_field.cont_type;
}
