public override void Validate(ComputationContext ctx)
{
base.Validate(ctx);
{ // detecting function duplicates
var functions = NestedFunctions.StoreReadOnlyList();
for (int a = 0; a < functions.Count; ++a)
{
for (int b = a + 1; b < functions.Count; ++b)
{
FunctionDefinition func_a = functions[a];
FunctionDefinition func_b = functions[b];
if (FunctionDefinitionExtension.IsOverloadedDuplicate(func_a, func_b))
{
ctx.ErrorManager.AddError(ErrorCode.OverloadingDuplicateFunctionDefinition, func_b, func_a);
}
}
}
}
// detecting entity duplicates
foreach (IEntity entity in this.NestedFields.Select(it => it.Cast <IEntity>())
.Concat(this.NestedTypes().Where(it => !it.IsTrait))
.Concat(this.NestedProperties.Where(it => !it.IsIndexer))
.GroupBy(it => it.Name, EntityNameArityComparer.Instance)
.Select(group => group.Skip(1).FirstOrDefault())
.Where(it => it != null))
{
ctx.ErrorManager.AddError(ErrorCode.NameAlreadyExists, entity);
}
IEntityScopeExtension.Validate(this, ctx);
}
public IErrorReporter InternalDirectTranslationTables()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
MiniEnvironment = true
}.SetMutability(mutability));
var root_ns = env.Root;
const string parent_typename = "Oldman";
const string parent_elemtype = "PT";
FunctionDefinition base_func = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(parent_elemtype));
TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename,
TemplateParametersBuffer.Create(parent_elemtype).Values))
.SetModifier(EntityModifier.Abstract)
.With(base_func));
const string child_typename = "Kid";
const string child_elemtype = "CT";
FunctionDefinition deriv_func = FunctionBuilder.Create("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(child_elemtype),
Block.CreateStatement(Return.Create(Undef.Create())))
.SetModifier(EntityModifier.Override);
TypeDefinition child = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename,
TemplateParametersBuffer.Create(child_elemtype).Values))
.Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype)))
.With(deriv_func));
resolver = NameResolver.Create(env);
// testing here template translation
EntityInstance child_ancestor = child.Inheritance.OrderedAncestorsWithoutObject.Single();
IEntityInstance translated = base_func.ResultTypeName.Evaluation.Components.TranslateThrough(child_ancestor);
// we have single function overriden, so it is easy to debug and spot if something goes wrong
bool result = FunctionDefinitionExtension.IsDerivedOf(resolver.Context, deriv_func, base_func, child_ancestor);
Assert.IsTrue(result);
}
return(resolver);
}
protected override void compute(ComputationContext ctx)
{
IEntityInstance eval = EntityInstanceUnion.Create(Elements.Select(it => it.Evaluation.Components));
// we need to get common members
bool has_reference = false;
bool has_pointer = false;
var dereferenced_instances = new List <EntityInstance>();
List <FunctionDefinition> members = null;
foreach (EntityInstance ____instance in this.Elements.Select(it => it.Evaluation.Aggregate))
{
if (ctx.Env.DereferencedOnce(____instance, out IEntityInstance __instance, out bool via_pointer))
{
if (via_pointer)
{
has_pointer = true;
}
else
{
has_reference = true;
}
}
EntityInstance instance = __instance.Cast <EntityInstance>();
dereferenced_instances.Add(instance);
if (members == null)
{
members = instance.TargetType.NestedFunctions
.Where(f => !f.IsAnyConstructor() && f.Parameters.All(it => !it.IsOptional))
.ToList();
}
else
{
foreach (FunctionDefinition m in members.ToArray())
{
bool found = false;
foreach (FunctionDefinition func in instance.TargetType.NestedFunctions)
{
// todo: maybe some day handle optionals
if (func.IsAnyConstructor() || func.Parameters.Any(it => it.IsOptional))
{
continue;
}
if (FunctionDefinitionExtension.IsSame(ctx, m, func, instance))
{
found = true;
break;
}
}
if (!found)
{
members.Remove(m);
}
}
}
}
EntityInstance aggregate_instance = createAggregate(ctx, has_reference, has_pointer,
dereferenced_instances, members, partialVirtualTables: false);
this.Evaluation = new EvaluationInfo(eval, aggregate_instance);
}
