override public void OnReferenceExpression(ReferenceExpression node)
{
IExternalEntity member = node.Entity as IExternalEntity;
if (member == null) //extract to OnInternalReferenceExpression
{
OnInternalReferenceExpression(node);
return;
}
System.Attribute[] attributes = System.Attribute.GetCustomAttributes(member.MemberInfo, typeof(ObsoleteAttribute));
foreach (ObsoleteAttribute attr in attributes)
{
if (attr.IsError)
{
Errors.Add(
CompilerErrorFactory.Obsolete(node, member.ToString(), attr.Message));
}
else
{
Warnings.Add(
CompilerWarningFactory.Obsolete(node, member.ToString(), attr.Message));
}
}
}
private static Type AttributeType(Ast.Attribute node)
{
IExternalEntity attr = node.Entity as IExternalEntity;
if (null == attr)
{
return(null);
}
return(attr.MemberInfo.DeclaringType);
}
override public void OnAttribute(Boo.Lang.Compiler.Ast.Attribute node)
{
Type attrType = AttributeType(node);
if (attrType == null)
{
return;
}
// check allowed attribute usage(s)
System.Attribute[] usages = System.Attribute.GetCustomAttributes(attrType, typeof(AttributeUsageAttribute));
if (usages.Length == 0)
{
return;
}
//only one AttributeUsage is allowed anyway
AttributeUsageAttribute usage = (AttributeUsageAttribute)usages[0];
if (AttributeTargets.All != usage.ValidOn)
{
AttributeTargets?target = TargetFor(node);
if (target.HasValue && !IsValid(usage, target.Value))
{
Errors.Add(
CompilerErrorFactory.InvalidAttributeTarget(node, attrType, usage.ValidOn));
}
}
if (!usage.AllowMultiple)
{
INodeWithAttributes m = node.ParentNode as INodeWithAttributes;
foreach (Boo.Lang.Compiler.Ast.Attribute mAttr in m.Attributes)
{
if (mAttr == node)
{
continue;
}
IExternalEntity mAttrEnt = mAttr.Entity as IExternalEntity;
if (null != mAttrEnt && mAttrEnt.MemberInfo.DeclaringType == attrType)
{
Errors.Add(
CompilerErrorFactory.MultipleAttributeUsage(node, attrType));
}
}
}
// handle special compiler-supported attributes
//TODO: ObsoleteAttribute
}
