//Добавляет интерфейс и всех его предков в список реализуемых данным классом. 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); }
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; }