//(ssyy) Сохранение инстанции generic-класса
private void WriteGenericTypeInstance(generic_instance_type_node gitn)
{
bw.Write((byte)TypeKind.GenericInstance);
//Пишем ссылку на описание generic-типа
WriteTypeReference(gitn.original_generic);
WriteTypeList(gitn.instance_params);
}
public void SetBaseTypeIgnoringScope(type_node base_type)
{
_base_type = base_type;
if (base_type != null)
{
_base_generic_instance = base_type.base_generic_instance;
}
}
public void SetBaseType(type_node base_type)
{
if (base_type == null)
{
_base_type = null;
_scope.BaseClassScope = null;
return;
}
_base_type = base_type;
if (_scope != null)
{
_scope.BaseClassScope = _base_type.Scope;
}
_base_generic_instance = base_type.base_generic_instance;
}
public static void init_generic_instance(type_node original, generic_instance_type_node instance, /*SymbolTable.ClassScope instance_scope,*/ List<type_node> param_types)
{
instance.IsInterface = original.IsInterface;
instance.is_class = original.is_class;
instance.internal_is_value = original.is_value;
instance.SetIsSealed(original.IsSealed);
instance.IsDelegate = original.IsDelegate;
instance.type_special_kind = original.type_special_kind;
//Определяем базовый тип
type_node btype = determine_type(
original.base_type, param_types, false);
instance.SetBaseTypeIgnoringScope(btype);
//instance._scope = new SymbolTable.GenericTypeInstanceScope(instance, instance.original_generic.Scope, btype.Scope);
foreach (type_node interf in original.ImplementingInterfaces)
{
instance.ImplementingInterfaces.Add(
determine_type(interf, param_types, false)
);
}
SystemLibrary.SystemLibrary.init_reference_type(instance);
instance.conform_basic_functions();
//(ssyy) Нужно, чтобы добавились конструкторы
//ctnode.find_in_type(compiler_string_consts.default_constructor_name);
instance.instance_params = param_types;
property_node orig_pn = original.default_property_node;
if (orig_pn != null)
{
if (orig_pn.comprehensive_type == original)
{
//Свойство по умолчанию описано в оригинальном коде generic-a;
//конвертируем его
instance.default_property = instance.ConvertMember(orig_pn) as common_property_node;
}
else
{
//Свойство по умолчанию описано в каком-то предке оригинального generic-a
if (orig_pn.comprehensive_type.is_generic_type_definition)
{
instance.default_property = instance.find_instance_type_from(orig_pn.comprehensive_type).default_property;
}
}
}
var shouldAddToAllTypeInstances = true;
if (LambdaHelper.processingLambdaParametersForTypeInference != 0)
{
foreach (var par in instance.generic_parameters)
{
if (par is lambda_any_type_node)
{
shouldAddToAllTypeInstances = false;
break;
}
}
}
if (shouldAddToAllTypeInstances) //lroman// Если зашли сюда при выведении типов параметров лямбды, то тип инстанцироваться может с типом lambda_any_type_node. Поэтому, если выводим типы. То данную инстанцию не добавляем
generic_convertions.all_type_instances.Add(instance);
internal_interface ii = original.get_internal_interface(internal_interface_kind.delegate_interface);
if (ii != null)
{
delegate_internal_interface dii = ii as delegate_internal_interface;
common_method_node inv = instance.ConvertMember(dii.invoke_method) as common_method_node;
common_method_node constr = instance.ConvertMember(dii.constructor) as common_method_node;
constr.function_code = new runtime_statement(SemanticTree.runtime_statement_type.ctor_delegate, null);
delegate_internal_interface converted_dii = new delegate_internal_interface(inv.return_value_type,
inv, constr);
converted_dii.parameters.AddRange(inv.parameters);
instance.add_internal_interface(converted_dii);
}
}
public generic_type_instance_info(List<type_node> _param_types, generic_instance_type_node _pseudo_instance)
{
param_types = _param_types;
pseudo_instance = _pseudo_instance;
}
public type_instance_and_location(generic_instance_type_node _instance, location _loc)
{
instance = _instance;
loc = _loc;
}
