bool CheckInheritedPropertyImpl(IProperty impl, IProperty target)
{
if (impl.Type == target.Type)
{
if (TypeSystemServices.CheckOverrideSignature(impl.GetParameters(), target.GetParameters()))
{
if (HasGetter(target))
{
if (!HasGetter(impl))
{
return(false);
}
}
if (HasSetter(target))
{
if (!HasSetter(impl))
{
return(false);
}
}
/* Unnecessary?
* if(impl.IsPublic != target.IsPublic ||
* impl.IsProtected != target.IsProtected ||
* impl.IsPrivate != target.IsPrivate)
* {
* return false;
* }*/
return(true);
}
}
return(false);
}
void ResolveClassAbstractProperty(ClassDefinition node,
TypeReference baseTypeRef,
IProperty entity)
{
foreach (TypeMember member in node.Members)
{
if (entity.Name != member.Name ||
NodeType.Property != member.NodeType ||
!IsCorrectExplicitMemberImplOrNoExplicitMemberAtAll(member, entity) ||
!TypeSystemServices.CheckOverrideSignature(entity.GetParameters(), GetPropertyEntity(member).GetParameters()))
{
continue;
}
Property p = (Property)member;
ProcessPropertyAccessor(p, p.Getter, entity.GetGetMethod());
ProcessPropertyAccessor(p, p.Setter, entity.GetSetMethod());
if (null == p.Type)
{
p.Type = CodeBuilder.CreateTypeReference(entity.Type);
}
else
{
if (entity.Type != p.Type.Entity)
{
Error(CompilerErrorFactory.ConflictWithInheritedMember(p, p.FullName, entity.FullName));
}
}
return;
}
node.Members.Add(CreateAbstractProperty(baseTypeRef, entity));
AbstractMemberNotImplemented(node, baseTypeRef, entity);
}
private bool ResolveAsImplementationOf(IProperty baseProperty, Property property)
{
if (!TypeSystemServices.CheckOverrideSignature(GetEntity(property).GetParameters(), baseProperty.GetParameters()))
{
return(false);
}
ProcessPropertyImplementation(property, baseProperty);
AssertValidPropertyImplementation(property, baseProperty);
return(true);
}
bool CheckInheritedMethodImpl(IMethod impl, IMethod target)
{
if (TypeSystemServices.CheckOverrideSignature(impl, target))
{
if (impl.ReturnType == target.ReturnType)
{
return(true);
}
//TODO: Oh snap! No reusable error messages for this!
//Errors(CompilerErrorFactory.ConflictWithInheritedMember());
}
return(false);
}
void ResolveAbstractMethod(ClassDefinition node,
TypeReference baseTypeRef,
IMethod entity)
{
if (entity.IsSpecialName)
{
return;
}
foreach (TypeMember member in node.Members)
{
if (entity.Name == member.Name &&
NodeType.Method == member.NodeType &&
IsCorrectExplicitMemberImplOrNoExplicitMemberAtAll(member, entity))
{
Method method = (Method)member;
if (TypeSystemServices.CheckOverrideSignature(GetEntity(method), entity))
{
if (IsUnknown(method.ReturnType))
{
method.ReturnType = CodeBuilder.CreateTypeReference(entity.ReturnType);
}
else
{
if (entity.ReturnType != method.ReturnType.Entity)
{
Error(CompilerErrorFactory.ConflictWithInheritedMember(method, method.FullName, entity.FullName));
}
}
if (null != method.ExplicitInfo)
{
method.ExplicitInfo.Entity = entity;
}
if (!method.IsOverride && !method.IsVirtual)
{
method.Modifiers |= TypeMemberModifiers.Virtual;
}
_context.TraceInfo("{0}: Method {1} implements {2}", method.LexicalInfo, method, entity);
return;
}
}
}
node.Members.Add(CodeBuilder.CreateAbstractMethod(baseTypeRef.LexicalInfo, entity));
AbstractMemberNotImplemented(node, baseTypeRef, entity);
}
private bool ResolveAsImplementationOf(IMethod baseMethod, Method method)
{
if (!TypeSystemServices.CheckOverrideSignature(GetEntity(method), baseMethod))
{
return(false);
}
ProcessMethodImplementation(method, baseMethod);
if (!method.IsOverride && !method.IsVirtual)
{
method.Modifiers |= TypeMemberModifiers.Virtual;
}
AssertValidInterfaceImplementation(method, baseMethod);
TraceImplements(method, baseMethod);
return(true);
}
bool CheckInheritedPropertyImpl(IProperty impl, IProperty target)
{
if (!TypeSystemServices.CheckOverrideSignature(impl.GetParameters(), target.GetParameters()))
{
return(false);
}
if (HasGetter(target) && !HasGetter(impl))
{
return(false);
}
if (HasSetter(target) && !HasSetter(impl))
{
return(false);
}
return(true);
}
void ResolveAbstractMethod(ClassDefinition node,
TypeReference baseTypeRef,
IMethod entity)
{
if (entity.IsSpecialName)
{
return;
}
foreach (TypeMember member in node.Members)
{
if (entity.Name == member.Name &&
NodeType.Method == member.NodeType &&
IsCorrectExplicitMemberImplOrNoExplicitMemberAtAll(member, entity))
{
Method method = (Method)member;
if (TypeSystemServices.CheckOverrideSignature(GetEntity(method), entity))
{
if (IsUnknown(method.ReturnType))
{
method.ReturnType = CodeBuilder.CreateTypeReference(entity.ReturnType);
}
else
{
if (entity.ReturnType != method.ReturnType.Entity)
{
Error(CompilerErrorFactory.ConflictWithInheritedMember(method, method.FullName, entity.FullName));
}
}
if (null != method.ExplicitInfo)
{
method.ExplicitInfo.Entity = entity;
}
if (!method.IsOverride && !method.IsVirtual)
{
method.Modifiers |= TypeMemberModifiers.Virtual;
}
_context.TraceInfo("{0}: Method {1} implements {2}", method.LexicalInfo, method, entity);
return;
}
}
}
foreach (SimpleTypeReference parent in node.BaseTypes)
{
if (_classDefinitionList.Contains(parent.Name))
{
depth++;
ResolveAbstractMethod(_classDefinitionList[parent.Name] as ClassDefinition, baseTypeRef, entity);
depth--;
}
}
if (CheckInheritsInterfaceImplementation(node, entity))
{
return;
}
if (depth == 0)
{
if (!AbstractMemberNotImplemented(node, baseTypeRef, entity))
{
//BEHAVIOR < 0.7.7: no stub, mark class as abstract
node.Members.Add(CodeBuilder.CreateAbstractMethod(baseTypeRef.LexicalInfo, entity));
}
}
}
bool CheckInheritedMethodImpl(IMethod impl, IMethod baseMethod)
{
return(TypeSystemServices.CheckOverrideSignature(impl, baseMethod));
}
