/// <inheritdoc/>
public bool IsEnumMemberAlreadyDeclared(IEnumMember enumMember)
{
// If there's only a single member, don't bother doing any more work
if (this.Members.Count == 1)
{
return(false);
}
var matchingMembers = this.Members
.Where(member => member.Name == enumMember.Name)
.TakeWhile(member => member.Node != enumMember.Node);
return(matchingMembers.Any());
}
/// <inheritdoc/>
public bool IsEnumValueAlreadyDeclared(IEnumMember enumMember)
{
// If the member has no value (i.e. its value was invalid for some reason)
// don't bother doing any more work.
if (enumMember.Value == null)
{
return(false);
}
// If there's only a single member, don't bother doing any more work
if (this.Members.Count == 1)
{
return(false);
}
var matchingMembers = this.Members
.Where(member => member.Value == enumMember.Value)
.TakeWhile(member => member.Node != enumMember.Node);
return(matchingMembers.Any());
}
public override void VisitEnumMember <TAttributeGroup, TDeclaringType>(
IEnumMember <TAttributeGroup, TDeclaringType> enumMember)
{
visitor.VisitEnumMemberWithReflection((EnumMemberWithReflection)(object)enumMember);
}
internal EnumMember(IEnumMember member) => Member = member;
internal EnumMember(IEnumMember member)
: base(member)
{
}
/// <inheritdoc/>
public virtual void VisitEnumMember(IEnumMember enumMember)
{
}
/// <inheritdoc />
public override void VisitEnumMember(IEnumMember node)
{
Register(node, node.Flags, DocNodeType.EnumMember, node.Name.GetText(), base.VisitEnumMember);
}
internal EnumMember(IEnumMember member)
{
Member = member;
}
private void AddEnumMemberMessages(IEnumMember enumMember)
{
if (enumMember.Name == null)
{
// The enum member name is missing: `= 1`
this.AddError(
CompilerMessageId.EnumMemberMustHaveAName,
enumMember.Node.EQUALS_OPERATOR().Symbol,
enumMember.Node.enumValue);
}
switch (enumMember.InvalidValueReason)
{
case InvalidEnumValueReason.Negative:
// A negative enum value has been specified: `User = -1`.
this.AddError(
CompilerMessageId.EnumValueMustNotBeNegative,
enumMember.Node.enumValue);
break;
case InvalidEnumValueReason.NotAnInteger:
// A non-integer enum value has been specified: `User = "******"`.
this.AddError(
CompilerMessageId.EnumValueMustBeAnInteger,
enumMember.Node.enumValue);
break;
case InvalidEnumValueReason.InvalidHexValue:
// An invalid hex value has been specified: `User = 0xZZZ`.
this.AddError(
CompilerMessageId.EnumValueInvalidHex,
enumMember.Node.enumValue,
enumMember.RawValue);
break;
case InvalidEnumValueReason.Missing:
// An enum member has been defined with an equals sign, but a
// missing value: `User = `.
this.AddError(
CompilerMessageId.EnumValueMustBeSpecified,
enumMember.Node.IDENTIFIER().Symbol,
enumMember.Node.EQUALS_OPERATOR().Symbol);
break;
}
if (enumMember.Node.enumValue != null && enumMember.Node.EQUALS_OPERATOR() == null)
{
// An enum value has been specified without the = operator.
// For example `enum UserType { User 10 }`
this.AddError(
CompilerMessageId.EnumMemberEqualsOperatorMissing,
enumMember.Node.IDENTIFIER().Symbol,
enumMember.Node.enumValue);
}
if (enumMember.Parent.IsEnumMemberAlreadyDeclared(enumMember))
{
// The same enum member has been declared twice:
// ```
// enum UserType {
// User
// User
// }
// ```
this.AddError(
CompilerMessageId.EnumMemberDuplicated,
enumMember.Node.IDENTIFIER().Symbol,
enumMember.Name);
}
if (enumMember.Parent.IsEnumValueAlreadyDeclared(enumMember))
{
// The same enum value has already been used by another member:
// ```
// enum UserType {
// User = 1
// Administrator = 1
// }
// ```
this.AddError(
CompilerMessageId.EnumValueDuplicated,
enumMember.Node.enumValue,
enumMember.RawValue);
}
if (enumMember.IsValueImplicit)
{
// The enum member doesn't have a value provided:
// ```
// enum UserType {
// User
// }
// ```
this.AddWarning(
CompilerMessageId.EnumMemberHasImplicitValue,
enumMember.Node.IDENTIFIER().Symbol,
enumMember.Name,
enumMember.Value.ToString());
}
}
/// <inheritdoc />
public override void VisitEnumMember(IEnumMember enumMember)
{
this.AddEnumMemberMessages(enumMember);
base.VisitEnumMember(enumMember);
}
